// 蜂窝蜜造平台生成代码，如手工更改，请添加到 .beeignore 忽略生成

package com.fowo.api.model.order.rule;

import com.fowo.api.common.meta.MetaDataObject;
import com.fowo.api.common.meta.MetaDataObjects;
import com.fowo.api.common.model.PageSearch;
import com.fowo.api.common.mybatis.helper.PageSearchHelper;
import com.fowo.api.common.util.ListUtils;
import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import lombok.Getter;
import lombok.Setter;
import org.springframework.format.annotation.DateTimeFormat;

@Setter
@Getter
public class OrderRuleSearchParamPo extends PageSearch {

  private static MetaDataObject metaDataObject;

  @Override
  public void applySqlSegments() {
    if (metaDataObject == null) {
      metaDataObject =
        ListUtils.find(
          MetaDataObjects.getObjects(),
          o -> "OrderRule".equals(o.getName())
        );
    }
    PageSearchHelper.fillSqlSegments(this, metaDataObject);
  }

  @Override
  public void initFinal() {
    super.initFinal();
    applySqlSegments();
  }

  /**
   * 获取关联字段的查询表别名信息
   */
  @Override
  public Map<String, String> getJoinFieldTableAliasMap() {
    Map<String, String> map = new HashMap<>();
    map.put("splitBaseOrderSite", "sr");
    map.put("splitBaseOrderShopInfo", "si");
    map.put("splitWarehouseLogisticsCountry", "sc");
    map.put("splitOrderProduct", "p");
    map.put("splitOrderProductClassify", "c");
    map.put("splitOrderLogistics", "nlpv");
    map.put("joinBaseOrderSite", "sr2");
    map.put("joinBaseOrderShopInfo", "si2");
    map.put("joinOrderProduct", "p2");
    map.put("joinOrderProductClassify", "c2");
    map.put("joinOrderLogistics", "nlpv2");
    map.put("warehouseBaseOrderSite", "sr3");
    map.put("warehouseBaseOrderShopInfo", "si3");
    map.put("warehouseWarehouseLogisticsCountry", "sc2");
    map.put("warehouseOrderProduct", "p3");
    map.put("warehouseOrderProductClassify", "c3");
    map.put("warehouseOrderLogistics", "nlpv3");
    map.put("warehouseActDeliveryWarehouse", "w");
    map.put("warehouseActOptionWarehouse", "w2");
    map.put("logisticsBaseOrderSite", "sr4");
    map.put("logisticsBaseOrderShopInfo", "si4");
    map.put("logisticsWarehouseLogisticsCountry", "sc3");
    map.put("logisticsOrderProduct", "p4");
    map.put("logisticsOrderProductClassify", "c4");
    map.put("logisticsOrderLogistics", "nlpv4");
    map.put("logisticsActChannel", "nlcv");
    map.put("logisticsActProvider", "nlpv5");
    map.put("addressBaseOrderSite", "sr5");
    map.put("addressBaseOrderShopInfo", "si5");
    map.put("addressWarehouseLogisticsDeliveryWarehouse", "w3");
    map.put("addressWarehouseLogisticsProvider", "nlpv6");
    map.put("addressWarehouseLogisticsChannel", "nlcv2");
    map.put("addressWarehouseLogisticsCountry", "sc4");
    map.put("addressOrderProduct", "p5");
    map.put("addressOrderProductClassify", "c5");
    map.put("addressOrderLogistics", "nlpv7");
    map.put("processBaseOrderSite", "sr6");
    map.put("processBaseOrderShopInfo", "si6");
    map.put("processWarehouseLogisticsDeliveryWarehouse", "w4");
    map.put("processWarehouseLogisticsProvider", "nlpv8");
    map.put("processWarehouseLogisticsChannel", "nlcv3");
    map.put("processWarehouseLogisticsCountry", "sc5");
    map.put("processOrderProduct", "p6");
    map.put("processOrderProductClassify", "c6");
    map.put("processOrderLogistics", "nlpv9");
    map.put("issuBaseOrderSite", "sr7");
    map.put("issuBaseOrderShopInfo", "si7");
    map.put("issuWarehouseLogisticsDeliveryWarehouse", "w5");
    map.put("issuWarehouseLogisticsProvider", "nlpv10");
    map.put("issuWarehouseLogisticsChannel", "nlcv4");
    map.put("issuOrderLogistics", "nlpv11");
    return map;
  }

  @Override
  public Map<String, OptionalJoinField> getOptionalJoinFields() {
    Map<String, OptionalJoinField> map = new HashMap<>();

    return map;
  }

  /**
   * 指定使用特定的视图过滤条件
   * <p>
   * 有效值包括：OrderRule/Split, OrderRule/Join, OrderRule/Warehouse, OrderRule/Logistics, OrderRule/Address, OrderRule/Process, OrderRule/Issu
   * </p>
   */
  private String byViewName;

  /**
   * 编号
   */
  private Long id;

  /**
   * 最小编号
   */
  private Long idMin;

  /**
   * 最大编号
   */
  private Long idMax;

  /**
   * 编号 比较(eq)
   */
  private Long idEq;
  /**
   * 编号 比较(neq)
   */
  private Long idNeq;
  /**
   * 编号 比较(gt)
   */
  private Long idGt;
  /**
   * 编号 比较(gte)
   */
  private Long idGte;
  /**
   * 编号 比较(lt)
   */
  private Long idLt;
  /**
   * 编号 比较(lte)
   */
  private Long idLte;
  /**
   * 编号 比较(contains)
   */
  private Long idContains;
  /**
   * 编号 比较(notcontains)
   */
  private Long idNotcontains;
  /**
   * 编号 比较(startswith)
   */
  private Long idStartswith;
  /**
   * 编号 比较(endswith)
   */
  private Long idEndswith;
  /**
   * 编号 比较(isnull)
   */
  private Boolean idIsnull;
  /**
   * 编号 比较(isnotnull)
   */
  private Boolean idIsnotnull;

  /**
   * 规则名称(模糊搜索)
   */
  private String name;

  /**
   * 规则名称 比较(eq)
   */
  private String nameEq;
  /**
   * 规则名称 比较(neq)
   */
  private String nameNeq;
  /**
   * 规则名称 比较(gt)
   */
  private String nameGt;
  /**
   * 规则名称 比较(gte)
   */
  private String nameGte;
  /**
   * 规则名称 比较(lt)
   */
  private String nameLt;
  /**
   * 规则名称 比较(lte)
   */
  private String nameLte;
  /**
   * 规则名称 比较(contains)
   */
  private String nameContains;
  /**
   * 规则名称 比较(notcontains)
   */
  private String nameNotcontains;
  /**
   * 规则名称 比较(startswith)
   */
  private String nameStartswith;
  /**
   * 规则名称 比较(endswith)
   */
  private String nameEndswith;
  /**
   * 规则名称 比较(isnull)
   */
  private Boolean nameIsnull;
  /**
   * 规则名称 比较(isnotnull)
   */
  private Boolean nameIsnotnull;

  /**
   * 规则名称(精确搜索)
   */
  private List<String> nameInList;

  /**
   * 规则类型
   */
  private String type;

  /**
   * 规则类型 比较(eq)
   */
  private String typeEq;
  /**
   * 规则类型 比较(neq)
   */
  private String typeNeq;
  /**
   * 规则类型 比较(gt)
   */
  private String typeGt;
  /**
   * 规则类型 比较(gte)
   */
  private String typeGte;
  /**
   * 规则类型 比较(lt)
   */
  private String typeLt;
  /**
   * 规则类型 比较(lte)
   */
  private String typeLte;
  /**
   * 规则类型 比较(contains)
   */
  private String typeContains;
  /**
   * 规则类型 比较(notcontains)
   */
  private String typeNotcontains;
  /**
   * 规则类型 比较(startswith)
   */
  private String typeStartswith;
  /**
   * 规则类型 比较(endswith)
   */
  private String typeEndswith;
  /**
   * 规则类型 比较(isnull)
   */
  private Boolean typeIsnull;
  /**
   * 规则类型 比较(isnotnull)
   */
  private Boolean typeIsnotnull;

  /**
   * 规则类型(精确搜索)
   */
  private List<String> typeInList;

  /**
   * 规则状态
   */
  private String status;

  /**
   * 规则状态 比较(eq)
   */
  private String statusEq;
  /**
   * 规则状态 比较(neq)
   */
  private String statusNeq;
  /**
   * 规则状态 比较(gt)
   */
  private String statusGt;
  /**
   * 规则状态 比较(gte)
   */
  private String statusGte;
  /**
   * 规则状态 比较(lt)
   */
  private String statusLt;
  /**
   * 规则状态 比较(lte)
   */
  private String statusLte;
  /**
   * 规则状态 比较(contains)
   */
  private String statusContains;
  /**
   * 规则状态 比较(notcontains)
   */
  private String statusNotcontains;
  /**
   * 规则状态 比较(startswith)
   */
  private String statusStartswith;
  /**
   * 规则状态 比较(endswith)
   */
  private String statusEndswith;
  /**
   * 规则状态 比较(isnull)
   */
  private Boolean statusIsnull;
  /**
   * 规则状态 比较(isnotnull)
   */
  private Boolean statusIsnotnull;

  /**
   * 规则状态(精确搜索)
   */
  private List<String> statusInList;

  /**
   * 捆绑产品拆分模式
   */
  private String splitSplitMode;

  /**
   * 捆绑产品拆分模式 比较(eq)
   */
  private String splitSplitModeEq;
  /**
   * 捆绑产品拆分模式 比较(neq)
   */
  private String splitSplitModeNeq;
  /**
   * 捆绑产品拆分模式 比较(gt)
   */
  private String splitSplitModeGt;
  /**
   * 捆绑产品拆分模式 比较(gte)
   */
  private String splitSplitModeGte;
  /**
   * 捆绑产品拆分模式 比较(lt)
   */
  private String splitSplitModeLt;
  /**
   * 捆绑产品拆分模式 比较(lte)
   */
  private String splitSplitModeLte;
  /**
   * 捆绑产品拆分模式 比较(contains)
   */
  private String splitSplitModeContains;
  /**
   * 捆绑产品拆分模式 比较(notcontains)
   */
  private String splitSplitModeNotcontains;
  /**
   * 捆绑产品拆分模式 比较(startswith)
   */
  private String splitSplitModeStartswith;
  /**
   * 捆绑产品拆分模式 比较(endswith)
   */
  private String splitSplitModeEndswith;
  /**
   * 捆绑产品拆分模式 比较(isnull)
   */
  private Boolean splitSplitModeIsnull;
  /**
   * 捆绑产品拆分模式 比较(isnotnull)
   */
  private Boolean splitSplitModeIsnotnull;

  /**
   * 捆绑产品拆分模式(精确搜索)
   */
  private List<String> splitSplitModeInList;

  /**
   * 订单来源
   */
  private String splitBaseOrderOriginal;

  /**
   * 订单来源 比较(eq)
   */
  private String splitBaseOrderOriginalEq;
  /**
   * 订单来源 比较(neq)
   */
  private String splitBaseOrderOriginalNeq;
  /**
   * 订单来源 比较(gt)
   */
  private String splitBaseOrderOriginalGt;
  /**
   * 订单来源 比较(gte)
   */
  private String splitBaseOrderOriginalGte;
  /**
   * 订单来源 比较(lt)
   */
  private String splitBaseOrderOriginalLt;
  /**
   * 订单来源 比较(lte)
   */
  private String splitBaseOrderOriginalLte;
  /**
   * 订单来源 比较(contains)
   */
  private String splitBaseOrderOriginalContains;
  /**
   * 订单来源 比较(notcontains)
   */
  private String splitBaseOrderOriginalNotcontains;
  /**
   * 订单来源 比较(startswith)
   */
  private String splitBaseOrderOriginalStartswith;
  /**
   * 订单来源 比较(endswith)
   */
  private String splitBaseOrderOriginalEndswith;
  /**
   * 订单来源 比较(isnull)
   */
  private Boolean splitBaseOrderOriginalIsnull;
  /**
   * 订单来源 比较(isnotnull)
   */
  private Boolean splitBaseOrderOriginalIsnotnull;

  /**
   * 订单来源(精确搜索)
   */
  private List<String> splitBaseOrderOriginalInList;

  /**
   * 订单类型
   */
  private String splitBaseOrderType;

  /**
   * 订单类型 比较(eq)
   */
  private String splitBaseOrderTypeEq;
  /**
   * 订单类型 比较(neq)
   */
  private String splitBaseOrderTypeNeq;
  /**
   * 订单类型 比较(gt)
   */
  private String splitBaseOrderTypeGt;
  /**
   * 订单类型 比较(gte)
   */
  private String splitBaseOrderTypeGte;
  /**
   * 订单类型 比较(lt)
   */
  private String splitBaseOrderTypeLt;
  /**
   * 订单类型 比较(lte)
   */
  private String splitBaseOrderTypeLte;
  /**
   * 订单类型 比较(contains)
   */
  private String splitBaseOrderTypeContains;
  /**
   * 订单类型 比较(notcontains)
   */
  private String splitBaseOrderTypeNotcontains;
  /**
   * 订单类型 比较(startswith)
   */
  private String splitBaseOrderTypeStartswith;
  /**
   * 订单类型 比较(endswith)
   */
  private String splitBaseOrderTypeEndswith;
  /**
   * 订单类型 比较(isnull)
   */
  private Boolean splitBaseOrderTypeIsnull;
  /**
   * 订单类型 比较(isnotnull)
   */
  private Boolean splitBaseOrderTypeIsnotnull;

  /**
   * 订单类型(精确搜索)
   */
  private List<String> splitBaseOrderTypeInList;

  /**
   * 订单平台
   */
  private String splitBaseOrderPlatform;

  /**
   * 订单平台 比较(eq)
   */
  private String splitBaseOrderPlatformEq;
  /**
   * 订单平台 比较(neq)
   */
  private String splitBaseOrderPlatformNeq;
  /**
   * 订单平台 比较(gt)
   */
  private String splitBaseOrderPlatformGt;
  /**
   * 订单平台 比较(gte)
   */
  private String splitBaseOrderPlatformGte;
  /**
   * 订单平台 比较(lt)
   */
  private String splitBaseOrderPlatformLt;
  /**
   * 订单平台 比较(lte)
   */
  private String splitBaseOrderPlatformLte;
  /**
   * 订单平台 比较(contains)
   */
  private String splitBaseOrderPlatformContains;
  /**
   * 订单平台 比较(notcontains)
   */
  private String splitBaseOrderPlatformNotcontains;
  /**
   * 订单平台 比较(startswith)
   */
  private String splitBaseOrderPlatformStartswith;
  /**
   * 订单平台 比较(endswith)
   */
  private String splitBaseOrderPlatformEndswith;
  /**
   * 订单平台 比较(isnull)
   */
  private Boolean splitBaseOrderPlatformIsnull;
  /**
   * 订单平台 比较(isnotnull)
   */
  private Boolean splitBaseOrderPlatformIsnotnull;

  /**
   * 订单平台(精确搜索)
   */
  private List<String> splitBaseOrderPlatformInList;

  /**
   * 订单站点
   */
  private Long splitBaseOrderSite;

  /**
   * 订单站点 比较(eq)
   */
  private Long splitBaseOrderSiteEq;
  /**
   * 订单站点 比较(neq)
   */
  private Long splitBaseOrderSiteNeq;
  /**
   * 订单站点 比较(gt)
   */
  private Long splitBaseOrderSiteGt;
  /**
   * 订单站点 比较(gte)
   */
  private Long splitBaseOrderSiteGte;
  /**
   * 订单站点 比较(lt)
   */
  private Long splitBaseOrderSiteLt;
  /**
   * 订单站点 比较(lte)
   */
  private Long splitBaseOrderSiteLte;
  /**
   * 订单站点 比较(contains)
   */
  private Long splitBaseOrderSiteContains;
  /**
   * 订单站点 比较(notcontains)
   */
  private Long splitBaseOrderSiteNotcontains;
  /**
   * 订单站点 比较(startswith)
   */
  private Long splitBaseOrderSiteStartswith;
  /**
   * 订单站点 比较(endswith)
   */
  private Long splitBaseOrderSiteEndswith;
  /**
   * 订单站点 比较(isnull)
   */
  private Boolean splitBaseOrderSiteIsnull;
  /**
   * 订单站点 比较(isnotnull)
   */
  private Boolean splitBaseOrderSiteIsnotnull;
  /**
   * 订单站点的名称 比较(eq)
   */
  private String splitBaseOrderSiteNameEq;
  /**
   * 订单站点的名称 比较(neq)
   */
  private String splitBaseOrderSiteNameNeq;
  /**
   * 订单站点的名称 比较(gt)
   */
  private String splitBaseOrderSiteNameGt;
  /**
   * 订单站点的名称 比较(gte)
   */
  private String splitBaseOrderSiteNameGte;
  /**
   * 订单站点的名称 比较(lt)
   */
  private String splitBaseOrderSiteNameLt;
  /**
   * 订单站点的名称 比较(lte)
   */
  private String splitBaseOrderSiteNameLte;
  /**
   * 订单站点的名称 比较(contains)
   */
  private String splitBaseOrderSiteNameContains;
  /**
   * 订单站点的名称 比较(notcontains)
   */
  private String splitBaseOrderSiteNameNotcontains;
  /**
   * 订单站点的名称 比较(startswith)
   */
  private String splitBaseOrderSiteNameStartswith;
  /**
   * 订单站点的名称 比较(endswith)
   */
  private String splitBaseOrderSiteNameEndswith;
  /**
   * 订单站点的名称 比较(isnull)
   */
  private Boolean splitBaseOrderSiteNameIsnull;
  /**
   * 订单站点的名称 比较(isnotnull)
   */
  private Boolean splitBaseOrderSiteNameIsnotnull;

  /**
   * 订单店铺
   */
  private Long splitBaseOrderShopInfo;

  /**
   * 订单店铺 比较(eq)
   */
  private Long splitBaseOrderShopInfoEq;
  /**
   * 订单店铺 比较(neq)
   */
  private Long splitBaseOrderShopInfoNeq;
  /**
   * 订单店铺 比较(gt)
   */
  private Long splitBaseOrderShopInfoGt;
  /**
   * 订单店铺 比较(gte)
   */
  private Long splitBaseOrderShopInfoGte;
  /**
   * 订单店铺 比较(lt)
   */
  private Long splitBaseOrderShopInfoLt;
  /**
   * 订单店铺 比较(lte)
   */
  private Long splitBaseOrderShopInfoLte;
  /**
   * 订单店铺 比较(contains)
   */
  private Long splitBaseOrderShopInfoContains;
  /**
   * 订单店铺 比较(notcontains)
   */
  private Long splitBaseOrderShopInfoNotcontains;
  /**
   * 订单店铺 比较(startswith)
   */
  private Long splitBaseOrderShopInfoStartswith;
  /**
   * 订单店铺 比较(endswith)
   */
  private Long splitBaseOrderShopInfoEndswith;
  /**
   * 订单店铺 比较(isnull)
   */
  private Boolean splitBaseOrderShopInfoIsnull;
  /**
   * 订单店铺 比较(isnotnull)
   */
  private Boolean splitBaseOrderShopInfoIsnotnull;
  /**
   * 订单店铺的名称 比较(eq)
   */
  private String splitBaseOrderShopInfoShopNameEq;
  /**
   * 订单店铺的名称 比较(neq)
   */
  private String splitBaseOrderShopInfoShopNameNeq;
  /**
   * 订单店铺的名称 比较(gt)
   */
  private String splitBaseOrderShopInfoShopNameGt;
  /**
   * 订单店铺的名称 比较(gte)
   */
  private String splitBaseOrderShopInfoShopNameGte;
  /**
   * 订单店铺的名称 比较(lt)
   */
  private String splitBaseOrderShopInfoShopNameLt;
  /**
   * 订单店铺的名称 比较(lte)
   */
  private String splitBaseOrderShopInfoShopNameLte;
  /**
   * 订单店铺的名称 比较(contains)
   */
  private String splitBaseOrderShopInfoShopNameContains;
  /**
   * 订单店铺的名称 比较(notcontains)
   */
  private String splitBaseOrderShopInfoShopNameNotcontains;
  /**
   * 订单店铺的名称 比较(startswith)
   */
  private String splitBaseOrderShopInfoShopNameStartswith;
  /**
   * 订单店铺的名称 比较(endswith)
   */
  private String splitBaseOrderShopInfoShopNameEndswith;
  /**
   * 订单店铺的名称 比较(isnull)
   */
  private Boolean splitBaseOrderShopInfoShopNameIsnull;
  /**
   * 订单店铺的名称 比较(isnotnull)
   */
  private Boolean splitBaseOrderShopInfoShopNameIsnotnull;

  /**
   * 收货国家/地区
   */
  private Long splitWarehouseLogisticsCountry;

  /**
   * 收货国家/地区 比较(eq)
   */
  private Long splitWarehouseLogisticsCountryEq;
  /**
   * 收货国家/地区 比较(neq)
   */
  private Long splitWarehouseLogisticsCountryNeq;
  /**
   * 收货国家/地区 比较(gt)
   */
  private Long splitWarehouseLogisticsCountryGt;
  /**
   * 收货国家/地区 比较(gte)
   */
  private Long splitWarehouseLogisticsCountryGte;
  /**
   * 收货国家/地区 比较(lt)
   */
  private Long splitWarehouseLogisticsCountryLt;
  /**
   * 收货国家/地区 比较(lte)
   */
  private Long splitWarehouseLogisticsCountryLte;
  /**
   * 收货国家/地区 比较(contains)
   */
  private Long splitWarehouseLogisticsCountryContains;
  /**
   * 收货国家/地区 比较(notcontains)
   */
  private Long splitWarehouseLogisticsCountryNotcontains;
  /**
   * 收货国家/地区 比较(startswith)
   */
  private Long splitWarehouseLogisticsCountryStartswith;
  /**
   * 收货国家/地区 比较(endswith)
   */
  private Long splitWarehouseLogisticsCountryEndswith;
  /**
   * 收货国家/地区 比较(isnull)
   */
  private Boolean splitWarehouseLogisticsCountryIsnull;
  /**
   * 收货国家/地区 比较(isnotnull)
   */
  private Boolean splitWarehouseLogisticsCountryIsnotnull;
  /**
   * 收货国家/地区的国家 比较(eq)
   */
  private String splitWarehouseLogisticsCountryCountryEq;
  /**
   * 收货国家/地区的国家 比较(neq)
   */
  private String splitWarehouseLogisticsCountryCountryNeq;
  /**
   * 收货国家/地区的国家 比较(gt)
   */
  private String splitWarehouseLogisticsCountryCountryGt;
  /**
   * 收货国家/地区的国家 比较(gte)
   */
  private String splitWarehouseLogisticsCountryCountryGte;
  /**
   * 收货国家/地区的国家 比较(lt)
   */
  private String splitWarehouseLogisticsCountryCountryLt;
  /**
   * 收货国家/地区的国家 比较(lte)
   */
  private String splitWarehouseLogisticsCountryCountryLte;
  /**
   * 收货国家/地区的国家 比较(contains)
   */
  private String splitWarehouseLogisticsCountryCountryContains;
  /**
   * 收货国家/地区的国家 比较(notcontains)
   */
  private String splitWarehouseLogisticsCountryCountryNotcontains;
  /**
   * 收货国家/地区的国家 比较(startswith)
   */
  private String splitWarehouseLogisticsCountryCountryStartswith;
  /**
   * 收货国家/地区的国家 比较(endswith)
   */
  private String splitWarehouseLogisticsCountryCountryEndswith;
  /**
   * 收货国家/地区的国家 比较(isnull)
   */
  private Boolean splitWarehouseLogisticsCountryCountryIsnull;
  /**
   * 收货国家/地区的国家 比较(isnotnull)
   */
  private Boolean splitWarehouseLogisticsCountryCountryIsnotnull;

  /**
   * 收货省/州(模糊搜索)
   */
  private String splitWarehouseLogisticsProvince;

  /**
   * 收货省/州 比较(eq)
   */
  private String splitWarehouseLogisticsProvinceEq;
  /**
   * 收货省/州 比较(neq)
   */
  private String splitWarehouseLogisticsProvinceNeq;
  /**
   * 收货省/州 比较(gt)
   */
  private String splitWarehouseLogisticsProvinceGt;
  /**
   * 收货省/州 比较(gte)
   */
  private String splitWarehouseLogisticsProvinceGte;
  /**
   * 收货省/州 比较(lt)
   */
  private String splitWarehouseLogisticsProvinceLt;
  /**
   * 收货省/州 比较(lte)
   */
  private String splitWarehouseLogisticsProvinceLte;
  /**
   * 收货省/州 比较(contains)
   */
  private String splitWarehouseLogisticsProvinceContains;
  /**
   * 收货省/州 比较(notcontains)
   */
  private String splitWarehouseLogisticsProvinceNotcontains;
  /**
   * 收货省/州 比较(startswith)
   */
  private String splitWarehouseLogisticsProvinceStartswith;
  /**
   * 收货省/州 比较(endswith)
   */
  private String splitWarehouseLogisticsProvinceEndswith;
  /**
   * 收货省/州 比较(isnull)
   */
  private Boolean splitWarehouseLogisticsProvinceIsnull;
  /**
   * 收货省/州 比较(isnotnull)
   */
  private Boolean splitWarehouseLogisticsProvinceIsnotnull;

  /**
   * 收货省/州(精确搜索)
   */
  private List<String> splitWarehouseLogisticsProvinceInList;

  /**
   * 收货城市(模糊搜索)
   */
  private String splitWarehouseLogisticsCity;

  /**
   * 收货城市 比较(eq)
   */
  private String splitWarehouseLogisticsCityEq;
  /**
   * 收货城市 比较(neq)
   */
  private String splitWarehouseLogisticsCityNeq;
  /**
   * 收货城市 比较(gt)
   */
  private String splitWarehouseLogisticsCityGt;
  /**
   * 收货城市 比较(gte)
   */
  private String splitWarehouseLogisticsCityGte;
  /**
   * 收货城市 比较(lt)
   */
  private String splitWarehouseLogisticsCityLt;
  /**
   * 收货城市 比较(lte)
   */
  private String splitWarehouseLogisticsCityLte;
  /**
   * 收货城市 比较(contains)
   */
  private String splitWarehouseLogisticsCityContains;
  /**
   * 收货城市 比较(notcontains)
   */
  private String splitWarehouseLogisticsCityNotcontains;
  /**
   * 收货城市 比较(startswith)
   */
  private String splitWarehouseLogisticsCityStartswith;
  /**
   * 收货城市 比较(endswith)
   */
  private String splitWarehouseLogisticsCityEndswith;
  /**
   * 收货城市 比较(isnull)
   */
  private Boolean splitWarehouseLogisticsCityIsnull;
  /**
   * 收货城市 比较(isnotnull)
   */
  private Boolean splitWarehouseLogisticsCityIsnotnull;

  /**
   * 收货城市(精确搜索)
   */
  private List<String> splitWarehouseLogisticsCityInList;

  /**
   * 收货邮编开头(模糊搜索)
   */
  private String splitWarehouseLogisticsPostCodeStart;

  /**
   * 收货邮编开头 比较(eq)
   */
  private String splitWarehouseLogisticsPostCodeStartEq;
  /**
   * 收货邮编开头 比较(neq)
   */
  private String splitWarehouseLogisticsPostCodeStartNeq;
  /**
   * 收货邮编开头 比较(gt)
   */
  private String splitWarehouseLogisticsPostCodeStartGt;
  /**
   * 收货邮编开头 比较(gte)
   */
  private String splitWarehouseLogisticsPostCodeStartGte;
  /**
   * 收货邮编开头 比较(lt)
   */
  private String splitWarehouseLogisticsPostCodeStartLt;
  /**
   * 收货邮编开头 比较(lte)
   */
  private String splitWarehouseLogisticsPostCodeStartLte;
  /**
   * 收货邮编开头 比较(contains)
   */
  private String splitWarehouseLogisticsPostCodeStartContains;
  /**
   * 收货邮编开头 比较(notcontains)
   */
  private String splitWarehouseLogisticsPostCodeStartNotcontains;
  /**
   * 收货邮编开头 比较(startswith)
   */
  private String splitWarehouseLogisticsPostCodeStartStartswith;
  /**
   * 收货邮编开头 比较(endswith)
   */
  private String splitWarehouseLogisticsPostCodeStartEndswith;
  /**
   * 收货邮编开头 比较(isnull)
   */
  private Boolean splitWarehouseLogisticsPostCodeStartIsnull;
  /**
   * 收货邮编开头 比较(isnotnull)
   */
  private Boolean splitWarehouseLogisticsPostCodeStartIsnotnull;

  /**
   * 收货邮编开头(精确搜索)
   */
  private List<String> splitWarehouseLogisticsPostCodeStartInList;

  /**
   * 收货邮编包含(模糊搜索)
   */
  private String splitWarehouseLogisticsContains;

  /**
   * 收货邮编包含 比较(eq)
   */
  private String splitWarehouseLogisticsContainsEq;
  /**
   * 收货邮编包含 比较(neq)
   */
  private String splitWarehouseLogisticsContainsNeq;
  /**
   * 收货邮编包含 比较(gt)
   */
  private String splitWarehouseLogisticsContainsGt;
  /**
   * 收货邮编包含 比较(gte)
   */
  private String splitWarehouseLogisticsContainsGte;
  /**
   * 收货邮编包含 比较(lt)
   */
  private String splitWarehouseLogisticsContainsLt;
  /**
   * 收货邮编包含 比较(lte)
   */
  private String splitWarehouseLogisticsContainsLte;
  /**
   * 收货邮编包含 比较(contains)
   */
  private String splitWarehouseLogisticsContainsContains;
  /**
   * 收货邮编包含 比较(notcontains)
   */
  private String splitWarehouseLogisticsContainsNotcontains;
  /**
   * 收货邮编包含 比较(startswith)
   */
  private String splitWarehouseLogisticsContainsStartswith;
  /**
   * 收货邮编包含 比较(endswith)
   */
  private String splitWarehouseLogisticsContainsEndswith;
  /**
   * 收货邮编包含 比较(isnull)
   */
  private Boolean splitWarehouseLogisticsContainsIsnull;
  /**
   * 收货邮编包含 比较(isnotnull)
   */
  private Boolean splitWarehouseLogisticsContainsIsnotnull;

  /**
   * 收货邮编包含(精确搜索)
   */
  private List<String> splitWarehouseLogisticsContainsInList;

  /**
   * 两项满足其中一项
   */
  private String splitWarehouseLogisticsChooseOne;

  /**
   * 两项满足其中一项 比较(eq)
   */
  private String splitWarehouseLogisticsChooseOneEq;
  /**
   * 两项满足其中一项 比较(neq)
   */
  private String splitWarehouseLogisticsChooseOneNeq;
  /**
   * 两项满足其中一项 比较(gt)
   */
  private String splitWarehouseLogisticsChooseOneGt;
  /**
   * 两项满足其中一项 比较(gte)
   */
  private String splitWarehouseLogisticsChooseOneGte;
  /**
   * 两项满足其中一项 比较(lt)
   */
  private String splitWarehouseLogisticsChooseOneLt;
  /**
   * 两项满足其中一项 比较(lte)
   */
  private String splitWarehouseLogisticsChooseOneLte;
  /**
   * 两项满足其中一项 比较(contains)
   */
  private String splitWarehouseLogisticsChooseOneContains;
  /**
   * 两项满足其中一项 比较(notcontains)
   */
  private String splitWarehouseLogisticsChooseOneNotcontains;
  /**
   * 两项满足其中一项 比较(startswith)
   */
  private String splitWarehouseLogisticsChooseOneStartswith;
  /**
   * 两项满足其中一项 比较(endswith)
   */
  private String splitWarehouseLogisticsChooseOneEndswith;
  /**
   * 两项满足其中一项 比较(isnull)
   */
  private Boolean splitWarehouseLogisticsChooseOneIsnull;
  /**
   * 两项满足其中一项 比较(isnotnull)
   */
  private Boolean splitWarehouseLogisticsChooseOneIsnotnull;

  /**
   * 两项满足其中一项(精确搜索)
   */
  private List<String> splitWarehouseLogisticsChooseOneInList;

  /**
   * 指定收货邮编(模糊搜索)
   */
  private String splitWarehouseLogisticsWhite;

  /**
   * 指定收货邮编 比较(eq)
   */
  private String splitWarehouseLogisticsWhiteEq;
  /**
   * 指定收货邮编 比较(neq)
   */
  private String splitWarehouseLogisticsWhiteNeq;
  /**
   * 指定收货邮编 比较(gt)
   */
  private String splitWarehouseLogisticsWhiteGt;
  /**
   * 指定收货邮编 比较(gte)
   */
  private String splitWarehouseLogisticsWhiteGte;
  /**
   * 指定收货邮编 比较(lt)
   */
  private String splitWarehouseLogisticsWhiteLt;
  /**
   * 指定收货邮编 比较(lte)
   */
  private String splitWarehouseLogisticsWhiteLte;
  /**
   * 指定收货邮编 比较(contains)
   */
  private String splitWarehouseLogisticsWhiteContains;
  /**
   * 指定收货邮编 比较(notcontains)
   */
  private String splitWarehouseLogisticsWhiteNotcontains;
  /**
   * 指定收货邮编 比较(startswith)
   */
  private String splitWarehouseLogisticsWhiteStartswith;
  /**
   * 指定收货邮编 比较(endswith)
   */
  private String splitWarehouseLogisticsWhiteEndswith;
  /**
   * 指定收货邮编 比较(isnull)
   */
  private Boolean splitWarehouseLogisticsWhiteIsnull;
  /**
   * 指定收货邮编 比较(isnotnull)
   */
  private Boolean splitWarehouseLogisticsWhiteIsnotnull;

  /**
   * 指定收货邮编(精确搜索)
   */
  private List<String> splitWarehouseLogisticsWhiteInList;

  /**
   * 排除收货邮编(模糊搜索)
   */
  private String splitWarehouseLogisticsBlack;

  /**
   * 排除收货邮编 比较(eq)
   */
  private String splitWarehouseLogisticsBlackEq;
  /**
   * 排除收货邮编 比较(neq)
   */
  private String splitWarehouseLogisticsBlackNeq;
  /**
   * 排除收货邮编 比较(gt)
   */
  private String splitWarehouseLogisticsBlackGt;
  /**
   * 排除收货邮编 比较(gte)
   */
  private String splitWarehouseLogisticsBlackGte;
  /**
   * 排除收货邮编 比较(lt)
   */
  private String splitWarehouseLogisticsBlackLt;
  /**
   * 排除收货邮编 比较(lte)
   */
  private String splitWarehouseLogisticsBlackLte;
  /**
   * 排除收货邮编 比较(contains)
   */
  private String splitWarehouseLogisticsBlackContains;
  /**
   * 排除收货邮编 比较(notcontains)
   */
  private String splitWarehouseLogisticsBlackNotcontains;
  /**
   * 排除收货邮编 比较(startswith)
   */
  private String splitWarehouseLogisticsBlackStartswith;
  /**
   * 排除收货邮编 比较(endswith)
   */
  private String splitWarehouseLogisticsBlackEndswith;
  /**
   * 排除收货邮编 比较(isnull)
   */
  private Boolean splitWarehouseLogisticsBlackIsnull;
  /**
   * 排除收货邮编 比较(isnotnull)
   */
  private Boolean splitWarehouseLogisticsBlackIsnotnull;

  /**
   * 排除收货邮编(精确搜索)
   */
  private List<String> splitWarehouseLogisticsBlackInList;

  /**
   * 地址类型
   */
  private String splitWarehouseLogisticsAddressType;

  /**
   * 地址类型 比较(eq)
   */
  private String splitWarehouseLogisticsAddressTypeEq;
  /**
   * 地址类型 比较(neq)
   */
  private String splitWarehouseLogisticsAddressTypeNeq;
  /**
   * 地址类型 比较(gt)
   */
  private String splitWarehouseLogisticsAddressTypeGt;
  /**
   * 地址类型 比较(gte)
   */
  private String splitWarehouseLogisticsAddressTypeGte;
  /**
   * 地址类型 比较(lt)
   */
  private String splitWarehouseLogisticsAddressTypeLt;
  /**
   * 地址类型 比较(lte)
   */
  private String splitWarehouseLogisticsAddressTypeLte;
  /**
   * 地址类型 比较(contains)
   */
  private String splitWarehouseLogisticsAddressTypeContains;
  /**
   * 地址类型 比较(notcontains)
   */
  private String splitWarehouseLogisticsAddressTypeNotcontains;
  /**
   * 地址类型 比较(startswith)
   */
  private String splitWarehouseLogisticsAddressTypeStartswith;
  /**
   * 地址类型 比较(endswith)
   */
  private String splitWarehouseLogisticsAddressTypeEndswith;
  /**
   * 地址类型 比较(isnull)
   */
  private Boolean splitWarehouseLogisticsAddressTypeIsnull;
  /**
   * 地址类型 比较(isnotnull)
   */
  private Boolean splitWarehouseLogisticsAddressTypeIsnotnull;

  /**
   * 地址类型(精确搜索)
   */
  private List<String> splitWarehouseLogisticsAddressTypeInList;

  /**
   * 订单产品
   */
  private Long splitOrderProduct;

  /**
   * 订单产品 比较(eq)
   */
  private Long splitOrderProductEq;
  /**
   * 订单产品 比较(neq)
   */
  private Long splitOrderProductNeq;
  /**
   * 订单产品 比较(gt)
   */
  private Long splitOrderProductGt;
  /**
   * 订单产品 比较(gte)
   */
  private Long splitOrderProductGte;
  /**
   * 订单产品 比较(lt)
   */
  private Long splitOrderProductLt;
  /**
   * 订单产品 比较(lte)
   */
  private Long splitOrderProductLte;
  /**
   * 订单产品 比较(contains)
   */
  private Long splitOrderProductContains;
  /**
   * 订单产品 比较(notcontains)
   */
  private Long splitOrderProductNotcontains;
  /**
   * 订单产品 比较(startswith)
   */
  private Long splitOrderProductStartswith;
  /**
   * 订单产品 比较(endswith)
   */
  private Long splitOrderProductEndswith;
  /**
   * 订单产品 比较(isnull)
   */
  private Boolean splitOrderProductIsnull;
  /**
   * 订单产品 比较(isnotnull)
   */
  private Boolean splitOrderProductIsnotnull;
  /**
   * 订单产品的品名 比较(eq)
   */
  private String splitOrderProductNameEq;
  /**
   * 订单产品的品名 比较(neq)
   */
  private String splitOrderProductNameNeq;
  /**
   * 订单产品的品名 比较(gt)
   */
  private String splitOrderProductNameGt;
  /**
   * 订单产品的品名 比较(gte)
   */
  private String splitOrderProductNameGte;
  /**
   * 订单产品的品名 比较(lt)
   */
  private String splitOrderProductNameLt;
  /**
   * 订单产品的品名 比较(lte)
   */
  private String splitOrderProductNameLte;
  /**
   * 订单产品的品名 比较(contains)
   */
  private String splitOrderProductNameContains;
  /**
   * 订单产品的品名 比较(notcontains)
   */
  private String splitOrderProductNameNotcontains;
  /**
   * 订单产品的品名 比较(startswith)
   */
  private String splitOrderProductNameStartswith;
  /**
   * 订单产品的品名 比较(endswith)
   */
  private String splitOrderProductNameEndswith;
  /**
   * 订单产品的品名 比较(isnull)
   */
  private Boolean splitOrderProductNameIsnull;
  /**
   * 订单产品的品名 比较(isnotnull)
   */
  private Boolean splitOrderProductNameIsnotnull;

  /**
   * 产品分类
   */
  private Long splitOrderProductClassify;

  /**
   * 产品分类 比较(eq)
   */
  private Long splitOrderProductClassifyEq;
  /**
   * 产品分类 比较(neq)
   */
  private Long splitOrderProductClassifyNeq;
  /**
   * 产品分类 比较(gt)
   */
  private Long splitOrderProductClassifyGt;
  /**
   * 产品分类 比较(gte)
   */
  private Long splitOrderProductClassifyGte;
  /**
   * 产品分类 比较(lt)
   */
  private Long splitOrderProductClassifyLt;
  /**
   * 产品分类 比较(lte)
   */
  private Long splitOrderProductClassifyLte;
  /**
   * 产品分类 比较(contains)
   */
  private Long splitOrderProductClassifyContains;
  /**
   * 产品分类 比较(notcontains)
   */
  private Long splitOrderProductClassifyNotcontains;
  /**
   * 产品分类 比较(startswith)
   */
  private Long splitOrderProductClassifyStartswith;
  /**
   * 产品分类 比较(endswith)
   */
  private Long splitOrderProductClassifyEndswith;
  /**
   * 产品分类 比较(isnull)
   */
  private Boolean splitOrderProductClassifyIsnull;
  /**
   * 产品分类 比较(isnotnull)
   */
  private Boolean splitOrderProductClassifyIsnotnull;
  /**
   * 产品分类的分类名称 比较(eq)
   */
  private String splitOrderProductClassifyNameEq;
  /**
   * 产品分类的分类名称 比较(neq)
   */
  private String splitOrderProductClassifyNameNeq;
  /**
   * 产品分类的分类名称 比较(gt)
   */
  private String splitOrderProductClassifyNameGt;
  /**
   * 产品分类的分类名称 比较(gte)
   */
  private String splitOrderProductClassifyNameGte;
  /**
   * 产品分类的分类名称 比较(lt)
   */
  private String splitOrderProductClassifyNameLt;
  /**
   * 产品分类的分类名称 比较(lte)
   */
  private String splitOrderProductClassifyNameLte;
  /**
   * 产品分类的分类名称 比较(contains)
   */
  private String splitOrderProductClassifyNameContains;
  /**
   * 产品分类的分类名称 比较(notcontains)
   */
  private String splitOrderProductClassifyNameNotcontains;
  /**
   * 产品分类的分类名称 比较(startswith)
   */
  private String splitOrderProductClassifyNameStartswith;
  /**
   * 产品分类的分类名称 比较(endswith)
   */
  private String splitOrderProductClassifyNameEndswith;
  /**
   * 产品分类的分类名称 比较(isnull)
   */
  private Boolean splitOrderProductClassifyNameIsnull;
  /**
   * 产品分类的分类名称 比较(isnotnull)
   */
  private Boolean splitOrderProductClassifyNameIsnotnull;

  /**
   * 产品数量
   */
  private String splitOrderMode;

  /**
   * 产品数量 比较(eq)
   */
  private String splitOrderModeEq;
  /**
   * 产品数量 比较(neq)
   */
  private String splitOrderModeNeq;
  /**
   * 产品数量 比较(gt)
   */
  private String splitOrderModeGt;
  /**
   * 产品数量 比较(gte)
   */
  private String splitOrderModeGte;
  /**
   * 产品数量 比较(lt)
   */
  private String splitOrderModeLt;
  /**
   * 产品数量 比较(lte)
   */
  private String splitOrderModeLte;
  /**
   * 产品数量 比较(contains)
   */
  private String splitOrderModeContains;
  /**
   * 产品数量 比较(notcontains)
   */
  private String splitOrderModeNotcontains;
  /**
   * 产品数量 比较(startswith)
   */
  private String splitOrderModeStartswith;
  /**
   * 产品数量 比较(endswith)
   */
  private String splitOrderModeEndswith;
  /**
   * 产品数量 比较(isnull)
   */
  private Boolean splitOrderModeIsnull;
  /**
   * 产品数量 比较(isnotnull)
   */
  private Boolean splitOrderModeIsnotnull;

  /**
   * 产品数量(精确搜索)
   */
  private List<String> splitOrderModeInList;

  /**
   * 总数量(模糊搜索)
   */
  private String splitOrderTotal;

  /**
   * 总数量 比较(eq)
   */
  private String splitOrderTotalEq;
  /**
   * 总数量 比较(neq)
   */
  private String splitOrderTotalNeq;
  /**
   * 总数量 比较(gt)
   */
  private String splitOrderTotalGt;
  /**
   * 总数量 比较(gte)
   */
  private String splitOrderTotalGte;
  /**
   * 总数量 比较(lt)
   */
  private String splitOrderTotalLt;
  /**
   * 总数量 比较(lte)
   */
  private String splitOrderTotalLte;
  /**
   * 总数量 比较(contains)
   */
  private String splitOrderTotalContains;
  /**
   * 总数量 比较(notcontains)
   */
  private String splitOrderTotalNotcontains;
  /**
   * 总数量 比较(startswith)
   */
  private String splitOrderTotalStartswith;
  /**
   * 总数量 比较(endswith)
   */
  private String splitOrderTotalEndswith;
  /**
   * 总数量 比较(isnull)
   */
  private Boolean splitOrderTotalIsnull;
  /**
   * 总数量 比较(isnotnull)
   */
  private Boolean splitOrderTotalIsnotnull;

  /**
   * 总数量(精确搜索)
   */
  private List<String> splitOrderTotalInList;

  /**
   * Sku数量(模糊搜索)
   */
  private String splitOrderSkuTotal;

  /**
   * Sku数量 比较(eq)
   */
  private String splitOrderSkuTotalEq;
  /**
   * Sku数量 比较(neq)
   */
  private String splitOrderSkuTotalNeq;
  /**
   * Sku数量 比较(gt)
   */
  private String splitOrderSkuTotalGt;
  /**
   * Sku数量 比较(gte)
   */
  private String splitOrderSkuTotalGte;
  /**
   * Sku数量 比较(lt)
   */
  private String splitOrderSkuTotalLt;
  /**
   * Sku数量 比较(lte)
   */
  private String splitOrderSkuTotalLte;
  /**
   * Sku数量 比较(contains)
   */
  private String splitOrderSkuTotalContains;
  /**
   * Sku数量 比较(notcontains)
   */
  private String splitOrderSkuTotalNotcontains;
  /**
   * Sku数量 比较(startswith)
   */
  private String splitOrderSkuTotalStartswith;
  /**
   * Sku数量 比较(endswith)
   */
  private String splitOrderSkuTotalEndswith;
  /**
   * Sku数量 比较(isnull)
   */
  private Boolean splitOrderSkuTotalIsnull;
  /**
   * Sku数量 比较(isnotnull)
   */
  private Boolean splitOrderSkuTotalIsnotnull;

  /**
   * Sku数量(精确搜索)
   */
  private List<String> splitOrderSkuTotalInList;

  /**
   * 估算重量(模糊搜索)
   */
  private String splitOrderThinkWeight;

  /**
   * 估算重量 比较(eq)
   */
  private String splitOrderThinkWeightEq;
  /**
   * 估算重量 比较(neq)
   */
  private String splitOrderThinkWeightNeq;
  /**
   * 估算重量 比较(gt)
   */
  private String splitOrderThinkWeightGt;
  /**
   * 估算重量 比较(gte)
   */
  private String splitOrderThinkWeightGte;
  /**
   * 估算重量 比较(lt)
   */
  private String splitOrderThinkWeightLt;
  /**
   * 估算重量 比较(lte)
   */
  private String splitOrderThinkWeightLte;
  /**
   * 估算重量 比较(contains)
   */
  private String splitOrderThinkWeightContains;
  /**
   * 估算重量 比较(notcontains)
   */
  private String splitOrderThinkWeightNotcontains;
  /**
   * 估算重量 比较(startswith)
   */
  private String splitOrderThinkWeightStartswith;
  /**
   * 估算重量 比较(endswith)
   */
  private String splitOrderThinkWeightEndswith;
  /**
   * 估算重量 比较(isnull)
   */
  private Boolean splitOrderThinkWeightIsnull;
  /**
   * 估算重量 比较(isnotnull)
   */
  private Boolean splitOrderThinkWeightIsnotnull;

  /**
   * 估算重量(精确搜索)
   */
  private List<String> splitOrderThinkWeightInList;

  /**
   * 估算尺寸(模糊搜索)
   */
  private String splitOrderThinkSize;

  /**
   * 估算尺寸 比较(eq)
   */
  private String splitOrderThinkSizeEq;
  /**
   * 估算尺寸 比较(neq)
   */
  private String splitOrderThinkSizeNeq;
  /**
   * 估算尺寸 比较(gt)
   */
  private String splitOrderThinkSizeGt;
  /**
   * 估算尺寸 比较(gte)
   */
  private String splitOrderThinkSizeGte;
  /**
   * 估算尺寸 比较(lt)
   */
  private String splitOrderThinkSizeLt;
  /**
   * 估算尺寸 比较(lte)
   */
  private String splitOrderThinkSizeLte;
  /**
   * 估算尺寸 比较(contains)
   */
  private String splitOrderThinkSizeContains;
  /**
   * 估算尺寸 比较(notcontains)
   */
  private String splitOrderThinkSizeNotcontains;
  /**
   * 估算尺寸 比较(startswith)
   */
  private String splitOrderThinkSizeStartswith;
  /**
   * 估算尺寸 比较(endswith)
   */
  private String splitOrderThinkSizeEndswith;
  /**
   * 估算尺寸 比较(isnull)
   */
  private Boolean splitOrderThinkSizeIsnull;
  /**
   * 估算尺寸 比较(isnotnull)
   */
  private Boolean splitOrderThinkSizeIsnotnull;

  /**
   * 估算尺寸(精确搜索)
   */
  private List<String> splitOrderThinkSizeInList;

  /**
   * 订单总金额(模糊搜索)
   */
  private String splitOrderTotalAmount;

  /**
   * 订单总金额 比较(eq)
   */
  private String splitOrderTotalAmountEq;
  /**
   * 订单总金额 比较(neq)
   */
  private String splitOrderTotalAmountNeq;
  /**
   * 订单总金额 比较(gt)
   */
  private String splitOrderTotalAmountGt;
  /**
   * 订单总金额 比较(gte)
   */
  private String splitOrderTotalAmountGte;
  /**
   * 订单总金额 比较(lt)
   */
  private String splitOrderTotalAmountLt;
  /**
   * 订单总金额 比较(lte)
   */
  private String splitOrderTotalAmountLte;
  /**
   * 订单总金额 比较(contains)
   */
  private String splitOrderTotalAmountContains;
  /**
   * 订单总金额 比较(notcontains)
   */
  private String splitOrderTotalAmountNotcontains;
  /**
   * 订单总金额 比较(startswith)
   */
  private String splitOrderTotalAmountStartswith;
  /**
   * 订单总金额 比较(endswith)
   */
  private String splitOrderTotalAmountEndswith;
  /**
   * 订单总金额 比较(isnull)
   */
  private Boolean splitOrderTotalAmountIsnull;
  /**
   * 订单总金额 比较(isnotnull)
   */
  private Boolean splitOrderTotalAmountIsnotnull;

  /**
   * 订单总金额(精确搜索)
   */
  private List<String> splitOrderTotalAmountInList;

  /**
   * 产品状态
   */
  private String splitOrderProductStatus;

  /**
   * 产品状态 比较(eq)
   */
  private String splitOrderProductStatusEq;
  /**
   * 产品状态 比较(neq)
   */
  private String splitOrderProductStatusNeq;
  /**
   * 产品状态 比较(gt)
   */
  private String splitOrderProductStatusGt;
  /**
   * 产品状态 比较(gte)
   */
  private String splitOrderProductStatusGte;
  /**
   * 产品状态 比较(lt)
   */
  private String splitOrderProductStatusLt;
  /**
   * 产品状态 比较(lte)
   */
  private String splitOrderProductStatusLte;
  /**
   * 产品状态 比较(contains)
   */
  private String splitOrderProductStatusContains;
  /**
   * 产品状态 比较(notcontains)
   */
  private String splitOrderProductStatusNotcontains;
  /**
   * 产品状态 比较(startswith)
   */
  private String splitOrderProductStatusStartswith;
  /**
   * 产品状态 比较(endswith)
   */
  private String splitOrderProductStatusEndswith;
  /**
   * 产品状态 比较(isnull)
   */
  private Boolean splitOrderProductStatusIsnull;
  /**
   * 产品状态 比较(isnotnull)
   */
  private Boolean splitOrderProductStatusIsnotnull;

  /**
   * 产品状态(精确搜索)
   */
  private List<String> splitOrderProductStatusInList;

  /**
   * 客选物流
   */
  private Long splitOrderLogistics;

  /**
   * 客选物流 比较(eq)
   */
  private Long splitOrderLogisticsEq;
  /**
   * 客选物流 比较(neq)
   */
  private Long splitOrderLogisticsNeq;
  /**
   * 客选物流 比较(gt)
   */
  private Long splitOrderLogisticsGt;
  /**
   * 客选物流 比较(gte)
   */
  private Long splitOrderLogisticsGte;
  /**
   * 客选物流 比较(lt)
   */
  private Long splitOrderLogisticsLt;
  /**
   * 客选物流 比较(lte)
   */
  private Long splitOrderLogisticsLte;
  /**
   * 客选物流 比较(contains)
   */
  private Long splitOrderLogisticsContains;
  /**
   * 客选物流 比较(notcontains)
   */
  private Long splitOrderLogisticsNotcontains;
  /**
   * 客选物流 比较(startswith)
   */
  private Long splitOrderLogisticsStartswith;
  /**
   * 客选物流 比较(endswith)
   */
  private Long splitOrderLogisticsEndswith;
  /**
   * 客选物流 比较(isnull)
   */
  private Boolean splitOrderLogisticsIsnull;
  /**
   * 客选物流 比较(isnotnull)
   */
  private Boolean splitOrderLogisticsIsnotnull;
  /**
   * 客选物流的名称 比较(eq)
   */
  private String splitOrderLogisticsLabelEq;
  /**
   * 客选物流的名称 比较(neq)
   */
  private String splitOrderLogisticsLabelNeq;
  /**
   * 客选物流的名称 比较(gt)
   */
  private String splitOrderLogisticsLabelGt;
  /**
   * 客选物流的名称 比较(gte)
   */
  private String splitOrderLogisticsLabelGte;
  /**
   * 客选物流的名称 比较(lt)
   */
  private String splitOrderLogisticsLabelLt;
  /**
   * 客选物流的名称 比较(lte)
   */
  private String splitOrderLogisticsLabelLte;
  /**
   * 客选物流的名称 比较(contains)
   */
  private String splitOrderLogisticsLabelContains;
  /**
   * 客选物流的名称 比较(notcontains)
   */
  private String splitOrderLogisticsLabelNotcontains;
  /**
   * 客选物流的名称 比较(startswith)
   */
  private String splitOrderLogisticsLabelStartswith;
  /**
   * 客选物流的名称 比较(endswith)
   */
  private String splitOrderLogisticsLabelEndswith;
  /**
   * 客选物流的名称 比较(isnull)
   */
  private Boolean splitOrderLogisticsLabelIsnull;
  /**
   * 客选物流的名称 比较(isnotnull)
   */
  private Boolean splitOrderLogisticsLabelIsnotnull;

  /**
   * 发货截止时间(模糊搜索)
   */
  private String splitOrderEndTime;

  /**
   * 发货截止时间 比较(eq)
   */
  private String splitOrderEndTimeEq;
  /**
   * 发货截止时间 比较(neq)
   */
  private String splitOrderEndTimeNeq;
  /**
   * 发货截止时间 比较(gt)
   */
  private String splitOrderEndTimeGt;
  /**
   * 发货截止时间 比较(gte)
   */
  private String splitOrderEndTimeGte;
  /**
   * 发货截止时间 比较(lt)
   */
  private String splitOrderEndTimeLt;
  /**
   * 发货截止时间 比较(lte)
   */
  private String splitOrderEndTimeLte;
  /**
   * 发货截止时间 比较(contains)
   */
  private String splitOrderEndTimeContains;
  /**
   * 发货截止时间 比较(notcontains)
   */
  private String splitOrderEndTimeNotcontains;
  /**
   * 发货截止时间 比较(startswith)
   */
  private String splitOrderEndTimeStartswith;
  /**
   * 发货截止时间 比较(endswith)
   */
  private String splitOrderEndTimeEndswith;
  /**
   * 发货截止时间 比较(isnull)
   */
  private Boolean splitOrderEndTimeIsnull;
  /**
   * 发货截止时间 比较(isnotnull)
   */
  private Boolean splitOrderEndTimeIsnotnull;

  /**
   * 发货截止时间(精确搜索)
   */
  private List<String> splitOrderEndTimeInList;

  /**
   * 特殊属性
   */
  private String splitOrderSpecial;

  /**
   * 特殊属性 比较(eq)
   */
  private String splitOrderSpecialEq;
  /**
   * 特殊属性 比较(neq)
   */
  private String splitOrderSpecialNeq;
  /**
   * 特殊属性 比较(gt)
   */
  private String splitOrderSpecialGt;
  /**
   * 特殊属性 比较(gte)
   */
  private String splitOrderSpecialGte;
  /**
   * 特殊属性 比较(lt)
   */
  private String splitOrderSpecialLt;
  /**
   * 特殊属性 比较(lte)
   */
  private String splitOrderSpecialLte;
  /**
   * 特殊属性 比较(contains)
   */
  private String splitOrderSpecialContains;
  /**
   * 特殊属性 比较(notcontains)
   */
  private String splitOrderSpecialNotcontains;
  /**
   * 特殊属性 比较(startswith)
   */
  private String splitOrderSpecialStartswith;
  /**
   * 特殊属性 比较(endswith)
   */
  private String splitOrderSpecialEndswith;
  /**
   * 特殊属性 比较(isnull)
   */
  private Boolean splitOrderSpecialIsnull;
  /**
   * 特殊属性 比较(isnotnull)
   */
  private Boolean splitOrderSpecialIsnotnull;

  /**
   * 特殊属性(精确搜索)
   */
  private List<String> splitOrderSpecialInList;

  /**
   * 毛利润率(模糊搜索)
   */
  private String splitOrderGrossMargin;

  /**
   * 毛利润率 比较(eq)
   */
  private String splitOrderGrossMarginEq;
  /**
   * 毛利润率 比较(neq)
   */
  private String splitOrderGrossMarginNeq;
  /**
   * 毛利润率 比较(gt)
   */
  private String splitOrderGrossMarginGt;
  /**
   * 毛利润率 比较(gte)
   */
  private String splitOrderGrossMarginGte;
  /**
   * 毛利润率 比较(lt)
   */
  private String splitOrderGrossMarginLt;
  /**
   * 毛利润率 比较(lte)
   */
  private String splitOrderGrossMarginLte;
  /**
   * 毛利润率 比较(contains)
   */
  private String splitOrderGrossMarginContains;
  /**
   * 毛利润率 比较(notcontains)
   */
  private String splitOrderGrossMarginNotcontains;
  /**
   * 毛利润率 比较(startswith)
   */
  private String splitOrderGrossMarginStartswith;
  /**
   * 毛利润率 比较(endswith)
   */
  private String splitOrderGrossMarginEndswith;
  /**
   * 毛利润率 比较(isnull)
   */
  private Boolean splitOrderGrossMarginIsnull;
  /**
   * 毛利润率 比较(isnotnull)
   */
  private Boolean splitOrderGrossMarginIsnotnull;

  /**
   * 毛利润率(精确搜索)
   */
  private List<String> splitOrderGrossMarginInList;

  /**
   * 执行动作
   */
  private String splitAct;

  /**
   * 执行动作 比较(eq)
   */
  private String splitActEq;
  /**
   * 执行动作 比较(neq)
   */
  private String splitActNeq;
  /**
   * 执行动作 比较(gt)
   */
  private String splitActGt;
  /**
   * 执行动作 比较(gte)
   */
  private String splitActGte;
  /**
   * 执行动作 比较(lt)
   */
  private String splitActLt;
  /**
   * 执行动作 比较(lte)
   */
  private String splitActLte;
  /**
   * 执行动作 比较(contains)
   */
  private String splitActContains;
  /**
   * 执行动作 比较(notcontains)
   */
  private String splitActNotcontains;
  /**
   * 执行动作 比较(startswith)
   */
  private String splitActStartswith;
  /**
   * 执行动作 比较(endswith)
   */
  private String splitActEndswith;
  /**
   * 执行动作 比较(isnull)
   */
  private Boolean splitActIsnull;
  /**
   * 执行动作 比较(isnotnull)
   */
  private Boolean splitActIsnotnull;

  /**
   * 执行动作(精确搜索)
   */
  private List<String> splitActInList;

  /**
   * 拆分方式
   */
  private String splitActMode;

  /**
   * 拆分方式 比较(eq)
   */
  private String splitActModeEq;
  /**
   * 拆分方式 比较(neq)
   */
  private String splitActModeNeq;
  /**
   * 拆分方式 比较(gt)
   */
  private String splitActModeGt;
  /**
   * 拆分方式 比较(gte)
   */
  private String splitActModeGte;
  /**
   * 拆分方式 比较(lt)
   */
  private String splitActModeLt;
  /**
   * 拆分方式 比较(lte)
   */
  private String splitActModeLte;
  /**
   * 拆分方式 比较(contains)
   */
  private String splitActModeContains;
  /**
   * 拆分方式 比较(notcontains)
   */
  private String splitActModeNotcontains;
  /**
   * 拆分方式 比较(startswith)
   */
  private String splitActModeStartswith;
  /**
   * 拆分方式 比较(endswith)
   */
  private String splitActModeEndswith;
  /**
   * 拆分方式 比较(isnull)
   */
  private Boolean splitActModeIsnull;
  /**
   * 拆分方式 比较(isnotnull)
   */
  private Boolean splitActModeIsnotnull;

  /**
   * 拆分方式(精确搜索)
   */
  private List<String> splitActModeInList;

  /**
   * 估算尺寸超过阈值则拆单(模糊搜索)
   */
  private String joinActSizeThreshold;

  /**
   * 估算尺寸超过阈值则拆单 比较(eq)
   */
  private String joinActSizeThresholdEq;
  /**
   * 估算尺寸超过阈值则拆单 比较(neq)
   */
  private String joinActSizeThresholdNeq;
  /**
   * 估算尺寸超过阈值则拆单 比较(gt)
   */
  private String joinActSizeThresholdGt;
  /**
   * 估算尺寸超过阈值则拆单 比较(gte)
   */
  private String joinActSizeThresholdGte;
  /**
   * 估算尺寸超过阈值则拆单 比较(lt)
   */
  private String joinActSizeThresholdLt;
  /**
   * 估算尺寸超过阈值则拆单 比较(lte)
   */
  private String joinActSizeThresholdLte;
  /**
   * 估算尺寸超过阈值则拆单 比较(contains)
   */
  private String joinActSizeThresholdContains;
  /**
   * 估算尺寸超过阈值则拆单 比较(notcontains)
   */
  private String joinActSizeThresholdNotcontains;
  /**
   * 估算尺寸超过阈值则拆单 比较(startswith)
   */
  private String joinActSizeThresholdStartswith;
  /**
   * 估算尺寸超过阈值则拆单 比较(endswith)
   */
  private String joinActSizeThresholdEndswith;
  /**
   * 估算尺寸超过阈值则拆单 比较(isnull)
   */
  private Boolean joinActSizeThresholdIsnull;
  /**
   * 估算尺寸超过阈值则拆单 比较(isnotnull)
   */
  private Boolean joinActSizeThresholdIsnotnull;

  /**
   * 估算尺寸超过阈值则拆单(精确搜索)
   */
  private List<String> joinActSizeThresholdInList;

  /**
   * 估算重量超过阈值则拆单(模糊搜索)
   */
  private String joinActWeightThreshold;

  /**
   * 估算重量超过阈值则拆单 比较(eq)
   */
  private String joinActWeightThresholdEq;
  /**
   * 估算重量超过阈值则拆单 比较(neq)
   */
  private String joinActWeightThresholdNeq;
  /**
   * 估算重量超过阈值则拆单 比较(gt)
   */
  private String joinActWeightThresholdGt;
  /**
   * 估算重量超过阈值则拆单 比较(gte)
   */
  private String joinActWeightThresholdGte;
  /**
   * 估算重量超过阈值则拆单 比较(lt)
   */
  private String joinActWeightThresholdLt;
  /**
   * 估算重量超过阈值则拆单 比较(lte)
   */
  private String joinActWeightThresholdLte;
  /**
   * 估算重量超过阈值则拆单 比较(contains)
   */
  private String joinActWeightThresholdContains;
  /**
   * 估算重量超过阈值则拆单 比较(notcontains)
   */
  private String joinActWeightThresholdNotcontains;
  /**
   * 估算重量超过阈值则拆单 比较(startswith)
   */
  private String joinActWeightThresholdStartswith;
  /**
   * 估算重量超过阈值则拆单 比较(endswith)
   */
  private String joinActWeightThresholdEndswith;
  /**
   * 估算重量超过阈值则拆单 比较(isnull)
   */
  private Boolean joinActWeightThresholdIsnull;
  /**
   * 估算重量超过阈值则拆单 比较(isnotnull)
   */
  private Boolean joinActWeightThresholdIsnotnull;

  /**
   * 估算重量超过阈值则拆单(精确搜索)
   */
  private List<String> joinActWeightThresholdInList;

  /**
   * 订单类型
   */
  private String joinBaseOrderType;

  /**
   * 订单类型 比较(eq)
   */
  private String joinBaseOrderTypeEq;
  /**
   * 订单类型 比较(neq)
   */
  private String joinBaseOrderTypeNeq;
  /**
   * 订单类型 比较(gt)
   */
  private String joinBaseOrderTypeGt;
  /**
   * 订单类型 比较(gte)
   */
  private String joinBaseOrderTypeGte;
  /**
   * 订单类型 比较(lt)
   */
  private String joinBaseOrderTypeLt;
  /**
   * 订单类型 比较(lte)
   */
  private String joinBaseOrderTypeLte;
  /**
   * 订单类型 比较(contains)
   */
  private String joinBaseOrderTypeContains;
  /**
   * 订单类型 比较(notcontains)
   */
  private String joinBaseOrderTypeNotcontains;
  /**
   * 订单类型 比较(startswith)
   */
  private String joinBaseOrderTypeStartswith;
  /**
   * 订单类型 比较(endswith)
   */
  private String joinBaseOrderTypeEndswith;
  /**
   * 订单类型 比较(isnull)
   */
  private Boolean joinBaseOrderTypeIsnull;
  /**
   * 订单类型 比较(isnotnull)
   */
  private Boolean joinBaseOrderTypeIsnotnull;

  /**
   * 订单类型(精确搜索)
   */
  private List<String> joinBaseOrderTypeInList;

  /**
   * 订单平台
   */
  private String joinBaseOrderPlatform;

  /**
   * 订单平台 比较(eq)
   */
  private String joinBaseOrderPlatformEq;
  /**
   * 订单平台 比较(neq)
   */
  private String joinBaseOrderPlatformNeq;
  /**
   * 订单平台 比较(gt)
   */
  private String joinBaseOrderPlatformGt;
  /**
   * 订单平台 比较(gte)
   */
  private String joinBaseOrderPlatformGte;
  /**
   * 订单平台 比较(lt)
   */
  private String joinBaseOrderPlatformLt;
  /**
   * 订单平台 比较(lte)
   */
  private String joinBaseOrderPlatformLte;
  /**
   * 订单平台 比较(contains)
   */
  private String joinBaseOrderPlatformContains;
  /**
   * 订单平台 比较(notcontains)
   */
  private String joinBaseOrderPlatformNotcontains;
  /**
   * 订单平台 比较(startswith)
   */
  private String joinBaseOrderPlatformStartswith;
  /**
   * 订单平台 比较(endswith)
   */
  private String joinBaseOrderPlatformEndswith;
  /**
   * 订单平台 比较(isnull)
   */
  private Boolean joinBaseOrderPlatformIsnull;
  /**
   * 订单平台 比较(isnotnull)
   */
  private Boolean joinBaseOrderPlatformIsnotnull;

  /**
   * 订单平台(精确搜索)
   */
  private List<String> joinBaseOrderPlatformInList;

  /**
   * 订单站点
   */
  private Long joinBaseOrderSite;

  /**
   * 订单站点 比较(eq)
   */
  private Long joinBaseOrderSiteEq;
  /**
   * 订单站点 比较(neq)
   */
  private Long joinBaseOrderSiteNeq;
  /**
   * 订单站点 比较(gt)
   */
  private Long joinBaseOrderSiteGt;
  /**
   * 订单站点 比较(gte)
   */
  private Long joinBaseOrderSiteGte;
  /**
   * 订单站点 比较(lt)
   */
  private Long joinBaseOrderSiteLt;
  /**
   * 订单站点 比较(lte)
   */
  private Long joinBaseOrderSiteLte;
  /**
   * 订单站点 比较(contains)
   */
  private Long joinBaseOrderSiteContains;
  /**
   * 订单站点 比较(notcontains)
   */
  private Long joinBaseOrderSiteNotcontains;
  /**
   * 订单站点 比较(startswith)
   */
  private Long joinBaseOrderSiteStartswith;
  /**
   * 订单站点 比较(endswith)
   */
  private Long joinBaseOrderSiteEndswith;
  /**
   * 订单站点 比较(isnull)
   */
  private Boolean joinBaseOrderSiteIsnull;
  /**
   * 订单站点 比较(isnotnull)
   */
  private Boolean joinBaseOrderSiteIsnotnull;
  /**
   * 订单站点的名称 比较(eq)
   */
  private String joinBaseOrderSiteNameEq;
  /**
   * 订单站点的名称 比较(neq)
   */
  private String joinBaseOrderSiteNameNeq;
  /**
   * 订单站点的名称 比较(gt)
   */
  private String joinBaseOrderSiteNameGt;
  /**
   * 订单站点的名称 比较(gte)
   */
  private String joinBaseOrderSiteNameGte;
  /**
   * 订单站点的名称 比较(lt)
   */
  private String joinBaseOrderSiteNameLt;
  /**
   * 订单站点的名称 比较(lte)
   */
  private String joinBaseOrderSiteNameLte;
  /**
   * 订单站点的名称 比较(contains)
   */
  private String joinBaseOrderSiteNameContains;
  /**
   * 订单站点的名称 比较(notcontains)
   */
  private String joinBaseOrderSiteNameNotcontains;
  /**
   * 订单站点的名称 比较(startswith)
   */
  private String joinBaseOrderSiteNameStartswith;
  /**
   * 订单站点的名称 比较(endswith)
   */
  private String joinBaseOrderSiteNameEndswith;
  /**
   * 订单站点的名称 比较(isnull)
   */
  private Boolean joinBaseOrderSiteNameIsnull;
  /**
   * 订单站点的名称 比较(isnotnull)
   */
  private Boolean joinBaseOrderSiteNameIsnotnull;

  /**
   * 订单店铺
   */
  private Long joinBaseOrderShopInfo;

  /**
   * 订单店铺 比较(eq)
   */
  private Long joinBaseOrderShopInfoEq;
  /**
   * 订单店铺 比较(neq)
   */
  private Long joinBaseOrderShopInfoNeq;
  /**
   * 订单店铺 比较(gt)
   */
  private Long joinBaseOrderShopInfoGt;
  /**
   * 订单店铺 比较(gte)
   */
  private Long joinBaseOrderShopInfoGte;
  /**
   * 订单店铺 比较(lt)
   */
  private Long joinBaseOrderShopInfoLt;
  /**
   * 订单店铺 比较(lte)
   */
  private Long joinBaseOrderShopInfoLte;
  /**
   * 订单店铺 比较(contains)
   */
  private Long joinBaseOrderShopInfoContains;
  /**
   * 订单店铺 比较(notcontains)
   */
  private Long joinBaseOrderShopInfoNotcontains;
  /**
   * 订单店铺 比较(startswith)
   */
  private Long joinBaseOrderShopInfoStartswith;
  /**
   * 订单店铺 比较(endswith)
   */
  private Long joinBaseOrderShopInfoEndswith;
  /**
   * 订单店铺 比较(isnull)
   */
  private Boolean joinBaseOrderShopInfoIsnull;
  /**
   * 订单店铺 比较(isnotnull)
   */
  private Boolean joinBaseOrderShopInfoIsnotnull;
  /**
   * 订单店铺的名称 比较(eq)
   */
  private String joinBaseOrderShopInfoShopNameEq;
  /**
   * 订单店铺的名称 比较(neq)
   */
  private String joinBaseOrderShopInfoShopNameNeq;
  /**
   * 订单店铺的名称 比较(gt)
   */
  private String joinBaseOrderShopInfoShopNameGt;
  /**
   * 订单店铺的名称 比较(gte)
   */
  private String joinBaseOrderShopInfoShopNameGte;
  /**
   * 订单店铺的名称 比较(lt)
   */
  private String joinBaseOrderShopInfoShopNameLt;
  /**
   * 订单店铺的名称 比较(lte)
   */
  private String joinBaseOrderShopInfoShopNameLte;
  /**
   * 订单店铺的名称 比较(contains)
   */
  private String joinBaseOrderShopInfoShopNameContains;
  /**
   * 订单店铺的名称 比较(notcontains)
   */
  private String joinBaseOrderShopInfoShopNameNotcontains;
  /**
   * 订单店铺的名称 比较(startswith)
   */
  private String joinBaseOrderShopInfoShopNameStartswith;
  /**
   * 订单店铺的名称 比较(endswith)
   */
  private String joinBaseOrderShopInfoShopNameEndswith;
  /**
   * 订单店铺的名称 比较(isnull)
   */
  private Boolean joinBaseOrderShopInfoShopNameIsnull;
  /**
   * 订单店铺的名称 比较(isnotnull)
   */
  private Boolean joinBaseOrderShopInfoShopNameIsnotnull;

  /**
   * 地址类型
   */
  private String joinWarehouseLogisticsAddressType;

  /**
   * 地址类型 比较(eq)
   */
  private String joinWarehouseLogisticsAddressTypeEq;
  /**
   * 地址类型 比较(neq)
   */
  private String joinWarehouseLogisticsAddressTypeNeq;
  /**
   * 地址类型 比较(gt)
   */
  private String joinWarehouseLogisticsAddressTypeGt;
  /**
   * 地址类型 比较(gte)
   */
  private String joinWarehouseLogisticsAddressTypeGte;
  /**
   * 地址类型 比较(lt)
   */
  private String joinWarehouseLogisticsAddressTypeLt;
  /**
   * 地址类型 比较(lte)
   */
  private String joinWarehouseLogisticsAddressTypeLte;
  /**
   * 地址类型 比较(contains)
   */
  private String joinWarehouseLogisticsAddressTypeContains;
  /**
   * 地址类型 比较(notcontains)
   */
  private String joinWarehouseLogisticsAddressTypeNotcontains;
  /**
   * 地址类型 比较(startswith)
   */
  private String joinWarehouseLogisticsAddressTypeStartswith;
  /**
   * 地址类型 比较(endswith)
   */
  private String joinWarehouseLogisticsAddressTypeEndswith;
  /**
   * 地址类型 比较(isnull)
   */
  private Boolean joinWarehouseLogisticsAddressTypeIsnull;
  /**
   * 地址类型 比较(isnotnull)
   */
  private Boolean joinWarehouseLogisticsAddressTypeIsnotnull;

  /**
   * 地址类型(精确搜索)
   */
  private List<String> joinWarehouseLogisticsAddressTypeInList;

  /**
   * 订单产品
   */
  private Long joinOrderProduct;

  /**
   * 订单产品 比较(eq)
   */
  private Long joinOrderProductEq;
  /**
   * 订单产品 比较(neq)
   */
  private Long joinOrderProductNeq;
  /**
   * 订单产品 比较(gt)
   */
  private Long joinOrderProductGt;
  /**
   * 订单产品 比较(gte)
   */
  private Long joinOrderProductGte;
  /**
   * 订单产品 比较(lt)
   */
  private Long joinOrderProductLt;
  /**
   * 订单产品 比较(lte)
   */
  private Long joinOrderProductLte;
  /**
   * 订单产品 比较(contains)
   */
  private Long joinOrderProductContains;
  /**
   * 订单产品 比较(notcontains)
   */
  private Long joinOrderProductNotcontains;
  /**
   * 订单产品 比较(startswith)
   */
  private Long joinOrderProductStartswith;
  /**
   * 订单产品 比较(endswith)
   */
  private Long joinOrderProductEndswith;
  /**
   * 订单产品 比较(isnull)
   */
  private Boolean joinOrderProductIsnull;
  /**
   * 订单产品 比较(isnotnull)
   */
  private Boolean joinOrderProductIsnotnull;
  /**
   * 订单产品的品名 比较(eq)
   */
  private String joinOrderProductNameEq;
  /**
   * 订单产品的品名 比较(neq)
   */
  private String joinOrderProductNameNeq;
  /**
   * 订单产品的品名 比较(gt)
   */
  private String joinOrderProductNameGt;
  /**
   * 订单产品的品名 比较(gte)
   */
  private String joinOrderProductNameGte;
  /**
   * 订单产品的品名 比较(lt)
   */
  private String joinOrderProductNameLt;
  /**
   * 订单产品的品名 比较(lte)
   */
  private String joinOrderProductNameLte;
  /**
   * 订单产品的品名 比较(contains)
   */
  private String joinOrderProductNameContains;
  /**
   * 订单产品的品名 比较(notcontains)
   */
  private String joinOrderProductNameNotcontains;
  /**
   * 订单产品的品名 比较(startswith)
   */
  private String joinOrderProductNameStartswith;
  /**
   * 订单产品的品名 比较(endswith)
   */
  private String joinOrderProductNameEndswith;
  /**
   * 订单产品的品名 比较(isnull)
   */
  private Boolean joinOrderProductNameIsnull;
  /**
   * 订单产品的品名 比较(isnotnull)
   */
  private Boolean joinOrderProductNameIsnotnull;

  /**
   * 产品分类
   */
  private Long joinOrderProductClassify;

  /**
   * 产品分类 比较(eq)
   */
  private Long joinOrderProductClassifyEq;
  /**
   * 产品分类 比较(neq)
   */
  private Long joinOrderProductClassifyNeq;
  /**
   * 产品分类 比较(gt)
   */
  private Long joinOrderProductClassifyGt;
  /**
   * 产品分类 比较(gte)
   */
  private Long joinOrderProductClassifyGte;
  /**
   * 产品分类 比较(lt)
   */
  private Long joinOrderProductClassifyLt;
  /**
   * 产品分类 比较(lte)
   */
  private Long joinOrderProductClassifyLte;
  /**
   * 产品分类 比较(contains)
   */
  private Long joinOrderProductClassifyContains;
  /**
   * 产品分类 比较(notcontains)
   */
  private Long joinOrderProductClassifyNotcontains;
  /**
   * 产品分类 比较(startswith)
   */
  private Long joinOrderProductClassifyStartswith;
  /**
   * 产品分类 比较(endswith)
   */
  private Long joinOrderProductClassifyEndswith;
  /**
   * 产品分类 比较(isnull)
   */
  private Boolean joinOrderProductClassifyIsnull;
  /**
   * 产品分类 比较(isnotnull)
   */
  private Boolean joinOrderProductClassifyIsnotnull;
  /**
   * 产品分类的分类名称 比较(eq)
   */
  private String joinOrderProductClassifyNameEq;
  /**
   * 产品分类的分类名称 比较(neq)
   */
  private String joinOrderProductClassifyNameNeq;
  /**
   * 产品分类的分类名称 比较(gt)
   */
  private String joinOrderProductClassifyNameGt;
  /**
   * 产品分类的分类名称 比较(gte)
   */
  private String joinOrderProductClassifyNameGte;
  /**
   * 产品分类的分类名称 比较(lt)
   */
  private String joinOrderProductClassifyNameLt;
  /**
   * 产品分类的分类名称 比较(lte)
   */
  private String joinOrderProductClassifyNameLte;
  /**
   * 产品分类的分类名称 比较(contains)
   */
  private String joinOrderProductClassifyNameContains;
  /**
   * 产品分类的分类名称 比较(notcontains)
   */
  private String joinOrderProductClassifyNameNotcontains;
  /**
   * 产品分类的分类名称 比较(startswith)
   */
  private String joinOrderProductClassifyNameStartswith;
  /**
   * 产品分类的分类名称 比较(endswith)
   */
  private String joinOrderProductClassifyNameEndswith;
  /**
   * 产品分类的分类名称 比较(isnull)
   */
  private Boolean joinOrderProductClassifyNameIsnull;
  /**
   * 产品分类的分类名称 比较(isnotnull)
   */
  private Boolean joinOrderProductClassifyNameIsnotnull;

  /**
   * 订单总金额(模糊搜索)
   */
  private String joinOrderTotalAmount;

  /**
   * 订单总金额 比较(eq)
   */
  private String joinOrderTotalAmountEq;
  /**
   * 订单总金额 比较(neq)
   */
  private String joinOrderTotalAmountNeq;
  /**
   * 订单总金额 比较(gt)
   */
  private String joinOrderTotalAmountGt;
  /**
   * 订单总金额 比较(gte)
   */
  private String joinOrderTotalAmountGte;
  /**
   * 订单总金额 比较(lt)
   */
  private String joinOrderTotalAmountLt;
  /**
   * 订单总金额 比较(lte)
   */
  private String joinOrderTotalAmountLte;
  /**
   * 订单总金额 比较(contains)
   */
  private String joinOrderTotalAmountContains;
  /**
   * 订单总金额 比较(notcontains)
   */
  private String joinOrderTotalAmountNotcontains;
  /**
   * 订单总金额 比较(startswith)
   */
  private String joinOrderTotalAmountStartswith;
  /**
   * 订单总金额 比较(endswith)
   */
  private String joinOrderTotalAmountEndswith;
  /**
   * 订单总金额 比较(isnull)
   */
  private Boolean joinOrderTotalAmountIsnull;
  /**
   * 订单总金额 比较(isnotnull)
   */
  private Boolean joinOrderTotalAmountIsnotnull;

  /**
   * 订单总金额(精确搜索)
   */
  private List<String> joinOrderTotalAmountInList;

  /**
   * 产品数量
   */
  private String joinOrderMode;

  /**
   * 产品数量 比较(eq)
   */
  private String joinOrderModeEq;
  /**
   * 产品数量 比较(neq)
   */
  private String joinOrderModeNeq;
  /**
   * 产品数量 比较(gt)
   */
  private String joinOrderModeGt;
  /**
   * 产品数量 比较(gte)
   */
  private String joinOrderModeGte;
  /**
   * 产品数量 比较(lt)
   */
  private String joinOrderModeLt;
  /**
   * 产品数量 比较(lte)
   */
  private String joinOrderModeLte;
  /**
   * 产品数量 比较(contains)
   */
  private String joinOrderModeContains;
  /**
   * 产品数量 比较(notcontains)
   */
  private String joinOrderModeNotcontains;
  /**
   * 产品数量 比较(startswith)
   */
  private String joinOrderModeStartswith;
  /**
   * 产品数量 比较(endswith)
   */
  private String joinOrderModeEndswith;
  /**
   * 产品数量 比较(isnull)
   */
  private Boolean joinOrderModeIsnull;
  /**
   * 产品数量 比较(isnotnull)
   */
  private Boolean joinOrderModeIsnotnull;

  /**
   * 产品数量(精确搜索)
   */
  private List<String> joinOrderModeInList;

  /**
   * 总数量(模糊搜索)
   */
  private String joinOrderTotal;

  /**
   * 总数量 比较(eq)
   */
  private String joinOrderTotalEq;
  /**
   * 总数量 比较(neq)
   */
  private String joinOrderTotalNeq;
  /**
   * 总数量 比较(gt)
   */
  private String joinOrderTotalGt;
  /**
   * 总数量 比较(gte)
   */
  private String joinOrderTotalGte;
  /**
   * 总数量 比较(lt)
   */
  private String joinOrderTotalLt;
  /**
   * 总数量 比较(lte)
   */
  private String joinOrderTotalLte;
  /**
   * 总数量 比较(contains)
   */
  private String joinOrderTotalContains;
  /**
   * 总数量 比较(notcontains)
   */
  private String joinOrderTotalNotcontains;
  /**
   * 总数量 比较(startswith)
   */
  private String joinOrderTotalStartswith;
  /**
   * 总数量 比较(endswith)
   */
  private String joinOrderTotalEndswith;
  /**
   * 总数量 比较(isnull)
   */
  private Boolean joinOrderTotalIsnull;
  /**
   * 总数量 比较(isnotnull)
   */
  private Boolean joinOrderTotalIsnotnull;

  /**
   * 总数量(精确搜索)
   */
  private List<String> joinOrderTotalInList;

  /**
   * Sku数量(模糊搜索)
   */
  private String joinOrderSkuTotal;

  /**
   * Sku数量 比较(eq)
   */
  private String joinOrderSkuTotalEq;
  /**
   * Sku数量 比较(neq)
   */
  private String joinOrderSkuTotalNeq;
  /**
   * Sku数量 比较(gt)
   */
  private String joinOrderSkuTotalGt;
  /**
   * Sku数量 比较(gte)
   */
  private String joinOrderSkuTotalGte;
  /**
   * Sku数量 比较(lt)
   */
  private String joinOrderSkuTotalLt;
  /**
   * Sku数量 比较(lte)
   */
  private String joinOrderSkuTotalLte;
  /**
   * Sku数量 比较(contains)
   */
  private String joinOrderSkuTotalContains;
  /**
   * Sku数量 比较(notcontains)
   */
  private String joinOrderSkuTotalNotcontains;
  /**
   * Sku数量 比较(startswith)
   */
  private String joinOrderSkuTotalStartswith;
  /**
   * Sku数量 比较(endswith)
   */
  private String joinOrderSkuTotalEndswith;
  /**
   * Sku数量 比较(isnull)
   */
  private Boolean joinOrderSkuTotalIsnull;
  /**
   * Sku数量 比较(isnotnull)
   */
  private Boolean joinOrderSkuTotalIsnotnull;

  /**
   * Sku数量(精确搜索)
   */
  private List<String> joinOrderSkuTotalInList;

  /**
   * 估算尺寸(模糊搜索)
   */
  private String joinOrderThinkSize;

  /**
   * 估算尺寸 比较(eq)
   */
  private String joinOrderThinkSizeEq;
  /**
   * 估算尺寸 比较(neq)
   */
  private String joinOrderThinkSizeNeq;
  /**
   * 估算尺寸 比较(gt)
   */
  private String joinOrderThinkSizeGt;
  /**
   * 估算尺寸 比较(gte)
   */
  private String joinOrderThinkSizeGte;
  /**
   * 估算尺寸 比较(lt)
   */
  private String joinOrderThinkSizeLt;
  /**
   * 估算尺寸 比较(lte)
   */
  private String joinOrderThinkSizeLte;
  /**
   * 估算尺寸 比较(contains)
   */
  private String joinOrderThinkSizeContains;
  /**
   * 估算尺寸 比较(notcontains)
   */
  private String joinOrderThinkSizeNotcontains;
  /**
   * 估算尺寸 比较(startswith)
   */
  private String joinOrderThinkSizeStartswith;
  /**
   * 估算尺寸 比较(endswith)
   */
  private String joinOrderThinkSizeEndswith;
  /**
   * 估算尺寸 比较(isnull)
   */
  private Boolean joinOrderThinkSizeIsnull;
  /**
   * 估算尺寸 比较(isnotnull)
   */
  private Boolean joinOrderThinkSizeIsnotnull;

  /**
   * 估算尺寸(精确搜索)
   */
  private List<String> joinOrderThinkSizeInList;

  /**
   * 估算重量(模糊搜索)
   */
  private String joinOrderThinkWeight;

  /**
   * 估算重量 比较(eq)
   */
  private String joinOrderThinkWeightEq;
  /**
   * 估算重量 比较(neq)
   */
  private String joinOrderThinkWeightNeq;
  /**
   * 估算重量 比较(gt)
   */
  private String joinOrderThinkWeightGt;
  /**
   * 估算重量 比较(gte)
   */
  private String joinOrderThinkWeightGte;
  /**
   * 估算重量 比较(lt)
   */
  private String joinOrderThinkWeightLt;
  /**
   * 估算重量 比较(lte)
   */
  private String joinOrderThinkWeightLte;
  /**
   * 估算重量 比较(contains)
   */
  private String joinOrderThinkWeightContains;
  /**
   * 估算重量 比较(notcontains)
   */
  private String joinOrderThinkWeightNotcontains;
  /**
   * 估算重量 比较(startswith)
   */
  private String joinOrderThinkWeightStartswith;
  /**
   * 估算重量 比较(endswith)
   */
  private String joinOrderThinkWeightEndswith;
  /**
   * 估算重量 比较(isnull)
   */
  private Boolean joinOrderThinkWeightIsnull;
  /**
   * 估算重量 比较(isnotnull)
   */
  private Boolean joinOrderThinkWeightIsnotnull;

  /**
   * 估算重量(精确搜索)
   */
  private List<String> joinOrderThinkWeightInList;

  /**
   * 客选物流
   */
  private Long joinOrderLogistics;

  /**
   * 客选物流 比较(eq)
   */
  private Long joinOrderLogisticsEq;
  /**
   * 客选物流 比较(neq)
   */
  private Long joinOrderLogisticsNeq;
  /**
   * 客选物流 比较(gt)
   */
  private Long joinOrderLogisticsGt;
  /**
   * 客选物流 比较(gte)
   */
  private Long joinOrderLogisticsGte;
  /**
   * 客选物流 比较(lt)
   */
  private Long joinOrderLogisticsLt;
  /**
   * 客选物流 比较(lte)
   */
  private Long joinOrderLogisticsLte;
  /**
   * 客选物流 比较(contains)
   */
  private Long joinOrderLogisticsContains;
  /**
   * 客选物流 比较(notcontains)
   */
  private Long joinOrderLogisticsNotcontains;
  /**
   * 客选物流 比较(startswith)
   */
  private Long joinOrderLogisticsStartswith;
  /**
   * 客选物流 比较(endswith)
   */
  private Long joinOrderLogisticsEndswith;
  /**
   * 客选物流 比较(isnull)
   */
  private Boolean joinOrderLogisticsIsnull;
  /**
   * 客选物流 比较(isnotnull)
   */
  private Boolean joinOrderLogisticsIsnotnull;
  /**
   * 客选物流的名称 比较(eq)
   */
  private String joinOrderLogisticsLabelEq;
  /**
   * 客选物流的名称 比较(neq)
   */
  private String joinOrderLogisticsLabelNeq;
  /**
   * 客选物流的名称 比较(gt)
   */
  private String joinOrderLogisticsLabelGt;
  /**
   * 客选物流的名称 比较(gte)
   */
  private String joinOrderLogisticsLabelGte;
  /**
   * 客选物流的名称 比较(lt)
   */
  private String joinOrderLogisticsLabelLt;
  /**
   * 客选物流的名称 比较(lte)
   */
  private String joinOrderLogisticsLabelLte;
  /**
   * 客选物流的名称 比较(contains)
   */
  private String joinOrderLogisticsLabelContains;
  /**
   * 客选物流的名称 比较(notcontains)
   */
  private String joinOrderLogisticsLabelNotcontains;
  /**
   * 客选物流的名称 比较(startswith)
   */
  private String joinOrderLogisticsLabelStartswith;
  /**
   * 客选物流的名称 比较(endswith)
   */
  private String joinOrderLogisticsLabelEndswith;
  /**
   * 客选物流的名称 比较(isnull)
   */
  private Boolean joinOrderLogisticsLabelIsnull;
  /**
   * 客选物流的名称 比较(isnotnull)
   */
  private Boolean joinOrderLogisticsLabelIsnotnull;

  /**
   * 特殊属性
   */
  private String joinOrderSpecial;

  /**
   * 特殊属性 比较(eq)
   */
  private String joinOrderSpecialEq;
  /**
   * 特殊属性 比较(neq)
   */
  private String joinOrderSpecialNeq;
  /**
   * 特殊属性 比较(gt)
   */
  private String joinOrderSpecialGt;
  /**
   * 特殊属性 比较(gte)
   */
  private String joinOrderSpecialGte;
  /**
   * 特殊属性 比较(lt)
   */
  private String joinOrderSpecialLt;
  /**
   * 特殊属性 比较(lte)
   */
  private String joinOrderSpecialLte;
  /**
   * 特殊属性 比较(contains)
   */
  private String joinOrderSpecialContains;
  /**
   * 特殊属性 比较(notcontains)
   */
  private String joinOrderSpecialNotcontains;
  /**
   * 特殊属性 比较(startswith)
   */
  private String joinOrderSpecialStartswith;
  /**
   * 特殊属性 比较(endswith)
   */
  private String joinOrderSpecialEndswith;
  /**
   * 特殊属性 比较(isnull)
   */
  private Boolean joinOrderSpecialIsnull;
  /**
   * 特殊属性 比较(isnotnull)
   */
  private Boolean joinOrderSpecialIsnotnull;

  /**
   * 特殊属性(精确搜索)
   */
  private List<String> joinOrderSpecialInList;

  /**
   * 毛利润率(模糊搜索)
   */
  private String joinOrderGrossMargin;

  /**
   * 毛利润率 比较(eq)
   */
  private String joinOrderGrossMarginEq;
  /**
   * 毛利润率 比较(neq)
   */
  private String joinOrderGrossMarginNeq;
  /**
   * 毛利润率 比较(gt)
   */
  private String joinOrderGrossMarginGt;
  /**
   * 毛利润率 比较(gte)
   */
  private String joinOrderGrossMarginGte;
  /**
   * 毛利润率 比较(lt)
   */
  private String joinOrderGrossMarginLt;
  /**
   * 毛利润率 比较(lte)
   */
  private String joinOrderGrossMarginLte;
  /**
   * 毛利润率 比较(contains)
   */
  private String joinOrderGrossMarginContains;
  /**
   * 毛利润率 比较(notcontains)
   */
  private String joinOrderGrossMarginNotcontains;
  /**
   * 毛利润率 比较(startswith)
   */
  private String joinOrderGrossMarginStartswith;
  /**
   * 毛利润率 比较(endswith)
   */
  private String joinOrderGrossMarginEndswith;
  /**
   * 毛利润率 比较(isnull)
   */
  private Boolean joinOrderGrossMarginIsnull;
  /**
   * 毛利润率 比较(isnotnull)
   */
  private Boolean joinOrderGrossMarginIsnotnull;

  /**
   * 毛利润率(精确搜索)
   */
  private List<String> joinOrderGrossMarginInList;

  /**
   * 合并方式
   */
  private String joinActMode;

  /**
   * 合并方式 比较(eq)
   */
  private String joinActModeEq;
  /**
   * 合并方式 比较(neq)
   */
  private String joinActModeNeq;
  /**
   * 合并方式 比较(gt)
   */
  private String joinActModeGt;
  /**
   * 合并方式 比较(gte)
   */
  private String joinActModeGte;
  /**
   * 合并方式 比较(lt)
   */
  private String joinActModeLt;
  /**
   * 合并方式 比较(lte)
   */
  private String joinActModeLte;
  /**
   * 合并方式 比较(contains)
   */
  private String joinActModeContains;
  /**
   * 合并方式 比较(notcontains)
   */
  private String joinActModeNotcontains;
  /**
   * 合并方式 比较(startswith)
   */
  private String joinActModeStartswith;
  /**
   * 合并方式 比较(endswith)
   */
  private String joinActModeEndswith;
  /**
   * 合并方式 比较(isnull)
   */
  private Boolean joinActModeIsnull;
  /**
   * 合并方式 比较(isnotnull)
   */
  private Boolean joinActModeIsnotnull;

  /**
   * 合并方式(精确搜索)
   */
  private List<String> joinActModeInList;

  /**
   * 订单平台
   */
  private String warehouseBaseOrderPlatform;

  /**
   * 订单平台 比较(eq)
   */
  private String warehouseBaseOrderPlatformEq;
  /**
   * 订单平台 比较(neq)
   */
  private String warehouseBaseOrderPlatformNeq;
  /**
   * 订单平台 比较(gt)
   */
  private String warehouseBaseOrderPlatformGt;
  /**
   * 订单平台 比较(gte)
   */
  private String warehouseBaseOrderPlatformGte;
  /**
   * 订单平台 比较(lt)
   */
  private String warehouseBaseOrderPlatformLt;
  /**
   * 订单平台 比较(lte)
   */
  private String warehouseBaseOrderPlatformLte;
  /**
   * 订单平台 比较(contains)
   */
  private String warehouseBaseOrderPlatformContains;
  /**
   * 订单平台 比较(notcontains)
   */
  private String warehouseBaseOrderPlatformNotcontains;
  /**
   * 订单平台 比较(startswith)
   */
  private String warehouseBaseOrderPlatformStartswith;
  /**
   * 订单平台 比较(endswith)
   */
  private String warehouseBaseOrderPlatformEndswith;
  /**
   * 订单平台 比较(isnull)
   */
  private Boolean warehouseBaseOrderPlatformIsnull;
  /**
   * 订单平台 比较(isnotnull)
   */
  private Boolean warehouseBaseOrderPlatformIsnotnull;

  /**
   * 订单平台(精确搜索)
   */
  private List<String> warehouseBaseOrderPlatformInList;

  /**
   * 订单站点
   */
  private Long warehouseBaseOrderSite;

  /**
   * 订单站点 比较(eq)
   */
  private Long warehouseBaseOrderSiteEq;
  /**
   * 订单站点 比较(neq)
   */
  private Long warehouseBaseOrderSiteNeq;
  /**
   * 订单站点 比较(gt)
   */
  private Long warehouseBaseOrderSiteGt;
  /**
   * 订单站点 比较(gte)
   */
  private Long warehouseBaseOrderSiteGte;
  /**
   * 订单站点 比较(lt)
   */
  private Long warehouseBaseOrderSiteLt;
  /**
   * 订单站点 比较(lte)
   */
  private Long warehouseBaseOrderSiteLte;
  /**
   * 订单站点 比较(contains)
   */
  private Long warehouseBaseOrderSiteContains;
  /**
   * 订单站点 比较(notcontains)
   */
  private Long warehouseBaseOrderSiteNotcontains;
  /**
   * 订单站点 比较(startswith)
   */
  private Long warehouseBaseOrderSiteStartswith;
  /**
   * 订单站点 比较(endswith)
   */
  private Long warehouseBaseOrderSiteEndswith;
  /**
   * 订单站点 比较(isnull)
   */
  private Boolean warehouseBaseOrderSiteIsnull;
  /**
   * 订单站点 比较(isnotnull)
   */
  private Boolean warehouseBaseOrderSiteIsnotnull;
  /**
   * 订单站点的名称 比较(eq)
   */
  private String warehouseBaseOrderSiteNameEq;
  /**
   * 订单站点的名称 比较(neq)
   */
  private String warehouseBaseOrderSiteNameNeq;
  /**
   * 订单站点的名称 比较(gt)
   */
  private String warehouseBaseOrderSiteNameGt;
  /**
   * 订单站点的名称 比较(gte)
   */
  private String warehouseBaseOrderSiteNameGte;
  /**
   * 订单站点的名称 比较(lt)
   */
  private String warehouseBaseOrderSiteNameLt;
  /**
   * 订单站点的名称 比较(lte)
   */
  private String warehouseBaseOrderSiteNameLte;
  /**
   * 订单站点的名称 比较(contains)
   */
  private String warehouseBaseOrderSiteNameContains;
  /**
   * 订单站点的名称 比较(notcontains)
   */
  private String warehouseBaseOrderSiteNameNotcontains;
  /**
   * 订单站点的名称 比较(startswith)
   */
  private String warehouseBaseOrderSiteNameStartswith;
  /**
   * 订单站点的名称 比较(endswith)
   */
  private String warehouseBaseOrderSiteNameEndswith;
  /**
   * 订单站点的名称 比较(isnull)
   */
  private Boolean warehouseBaseOrderSiteNameIsnull;
  /**
   * 订单站点的名称 比较(isnotnull)
   */
  private Boolean warehouseBaseOrderSiteNameIsnotnull;

  /**
   * 订单店铺
   */
  private Long warehouseBaseOrderShopInfo;

  /**
   * 订单店铺 比较(eq)
   */
  private Long warehouseBaseOrderShopInfoEq;
  /**
   * 订单店铺 比较(neq)
   */
  private Long warehouseBaseOrderShopInfoNeq;
  /**
   * 订单店铺 比较(gt)
   */
  private Long warehouseBaseOrderShopInfoGt;
  /**
   * 订单店铺 比较(gte)
   */
  private Long warehouseBaseOrderShopInfoGte;
  /**
   * 订单店铺 比较(lt)
   */
  private Long warehouseBaseOrderShopInfoLt;
  /**
   * 订单店铺 比较(lte)
   */
  private Long warehouseBaseOrderShopInfoLte;
  /**
   * 订单店铺 比较(contains)
   */
  private Long warehouseBaseOrderShopInfoContains;
  /**
   * 订单店铺 比较(notcontains)
   */
  private Long warehouseBaseOrderShopInfoNotcontains;
  /**
   * 订单店铺 比较(startswith)
   */
  private Long warehouseBaseOrderShopInfoStartswith;
  /**
   * 订单店铺 比较(endswith)
   */
  private Long warehouseBaseOrderShopInfoEndswith;
  /**
   * 订单店铺 比较(isnull)
   */
  private Boolean warehouseBaseOrderShopInfoIsnull;
  /**
   * 订单店铺 比较(isnotnull)
   */
  private Boolean warehouseBaseOrderShopInfoIsnotnull;
  /**
   * 订单店铺的名称 比较(eq)
   */
  private String warehouseBaseOrderShopInfoShopNameEq;
  /**
   * 订单店铺的名称 比较(neq)
   */
  private String warehouseBaseOrderShopInfoShopNameNeq;
  /**
   * 订单店铺的名称 比较(gt)
   */
  private String warehouseBaseOrderShopInfoShopNameGt;
  /**
   * 订单店铺的名称 比较(gte)
   */
  private String warehouseBaseOrderShopInfoShopNameGte;
  /**
   * 订单店铺的名称 比较(lt)
   */
  private String warehouseBaseOrderShopInfoShopNameLt;
  /**
   * 订单店铺的名称 比较(lte)
   */
  private String warehouseBaseOrderShopInfoShopNameLte;
  /**
   * 订单店铺的名称 比较(contains)
   */
  private String warehouseBaseOrderShopInfoShopNameContains;
  /**
   * 订单店铺的名称 比较(notcontains)
   */
  private String warehouseBaseOrderShopInfoShopNameNotcontains;
  /**
   * 订单店铺的名称 比较(startswith)
   */
  private String warehouseBaseOrderShopInfoShopNameStartswith;
  /**
   * 订单店铺的名称 比较(endswith)
   */
  private String warehouseBaseOrderShopInfoShopNameEndswith;
  /**
   * 订单店铺的名称 比较(isnull)
   */
  private Boolean warehouseBaseOrderShopInfoShopNameIsnull;
  /**
   * 订单店铺的名称 比较(isnotnull)
   */
  private Boolean warehouseBaseOrderShopInfoShopNameIsnotnull;

  /**
   * 收货国家/地区
   */
  private Long warehouseWarehouseLogisticsCountry;

  /**
   * 收货国家/地区 比较(eq)
   */
  private Long warehouseWarehouseLogisticsCountryEq;
  /**
   * 收货国家/地区 比较(neq)
   */
  private Long warehouseWarehouseLogisticsCountryNeq;
  /**
   * 收货国家/地区 比较(gt)
   */
  private Long warehouseWarehouseLogisticsCountryGt;
  /**
   * 收货国家/地区 比较(gte)
   */
  private Long warehouseWarehouseLogisticsCountryGte;
  /**
   * 收货国家/地区 比较(lt)
   */
  private Long warehouseWarehouseLogisticsCountryLt;
  /**
   * 收货国家/地区 比较(lte)
   */
  private Long warehouseWarehouseLogisticsCountryLte;
  /**
   * 收货国家/地区 比较(contains)
   */
  private Long warehouseWarehouseLogisticsCountryContains;
  /**
   * 收货国家/地区 比较(notcontains)
   */
  private Long warehouseWarehouseLogisticsCountryNotcontains;
  /**
   * 收货国家/地区 比较(startswith)
   */
  private Long warehouseWarehouseLogisticsCountryStartswith;
  /**
   * 收货国家/地区 比较(endswith)
   */
  private Long warehouseWarehouseLogisticsCountryEndswith;
  /**
   * 收货国家/地区 比较(isnull)
   */
  private Boolean warehouseWarehouseLogisticsCountryIsnull;
  /**
   * 收货国家/地区 比较(isnotnull)
   */
  private Boolean warehouseWarehouseLogisticsCountryIsnotnull;
  /**
   * 收货国家/地区的国家 比较(eq)
   */
  private String warehouseWarehouseLogisticsCountryCountryEq;
  /**
   * 收货国家/地区的国家 比较(neq)
   */
  private String warehouseWarehouseLogisticsCountryCountryNeq;
  /**
   * 收货国家/地区的国家 比较(gt)
   */
  private String warehouseWarehouseLogisticsCountryCountryGt;
  /**
   * 收货国家/地区的国家 比较(gte)
   */
  private String warehouseWarehouseLogisticsCountryCountryGte;
  /**
   * 收货国家/地区的国家 比较(lt)
   */
  private String warehouseWarehouseLogisticsCountryCountryLt;
  /**
   * 收货国家/地区的国家 比较(lte)
   */
  private String warehouseWarehouseLogisticsCountryCountryLte;
  /**
   * 收货国家/地区的国家 比较(contains)
   */
  private String warehouseWarehouseLogisticsCountryCountryContains;
  /**
   * 收货国家/地区的国家 比较(notcontains)
   */
  private String warehouseWarehouseLogisticsCountryCountryNotcontains;
  /**
   * 收货国家/地区的国家 比较(startswith)
   */
  private String warehouseWarehouseLogisticsCountryCountryStartswith;
  /**
   * 收货国家/地区的国家 比较(endswith)
   */
  private String warehouseWarehouseLogisticsCountryCountryEndswith;
  /**
   * 收货国家/地区的国家 比较(isnull)
   */
  private Boolean warehouseWarehouseLogisticsCountryCountryIsnull;
  /**
   * 收货国家/地区的国家 比较(isnotnull)
   */
  private Boolean warehouseWarehouseLogisticsCountryCountryIsnotnull;

  /**
   * 收货省/州(模糊搜索)
   */
  private String warehouseWarehouseLogisticsProvince;

  /**
   * 收货省/州 比较(eq)
   */
  private String warehouseWarehouseLogisticsProvinceEq;
  /**
   * 收货省/州 比较(neq)
   */
  private String warehouseWarehouseLogisticsProvinceNeq;
  /**
   * 收货省/州 比较(gt)
   */
  private String warehouseWarehouseLogisticsProvinceGt;
  /**
   * 收货省/州 比较(gte)
   */
  private String warehouseWarehouseLogisticsProvinceGte;
  /**
   * 收货省/州 比较(lt)
   */
  private String warehouseWarehouseLogisticsProvinceLt;
  /**
   * 收货省/州 比较(lte)
   */
  private String warehouseWarehouseLogisticsProvinceLte;
  /**
   * 收货省/州 比较(contains)
   */
  private String warehouseWarehouseLogisticsProvinceContains;
  /**
   * 收货省/州 比较(notcontains)
   */
  private String warehouseWarehouseLogisticsProvinceNotcontains;
  /**
   * 收货省/州 比较(startswith)
   */
  private String warehouseWarehouseLogisticsProvinceStartswith;
  /**
   * 收货省/州 比较(endswith)
   */
  private String warehouseWarehouseLogisticsProvinceEndswith;
  /**
   * 收货省/州 比较(isnull)
   */
  private Boolean warehouseWarehouseLogisticsProvinceIsnull;
  /**
   * 收货省/州 比较(isnotnull)
   */
  private Boolean warehouseWarehouseLogisticsProvinceIsnotnull;

  /**
   * 收货省/州(精确搜索)
   */
  private List<String> warehouseWarehouseLogisticsProvinceInList;

  /**
   * 收货城市(模糊搜索)
   */
  private String warehouseWarehouseLogisticsCity;

  /**
   * 收货城市 比较(eq)
   */
  private String warehouseWarehouseLogisticsCityEq;
  /**
   * 收货城市 比较(neq)
   */
  private String warehouseWarehouseLogisticsCityNeq;
  /**
   * 收货城市 比较(gt)
   */
  private String warehouseWarehouseLogisticsCityGt;
  /**
   * 收货城市 比较(gte)
   */
  private String warehouseWarehouseLogisticsCityGte;
  /**
   * 收货城市 比较(lt)
   */
  private String warehouseWarehouseLogisticsCityLt;
  /**
   * 收货城市 比较(lte)
   */
  private String warehouseWarehouseLogisticsCityLte;
  /**
   * 收货城市 比较(contains)
   */
  private String warehouseWarehouseLogisticsCityContains;
  /**
   * 收货城市 比较(notcontains)
   */
  private String warehouseWarehouseLogisticsCityNotcontains;
  /**
   * 收货城市 比较(startswith)
   */
  private String warehouseWarehouseLogisticsCityStartswith;
  /**
   * 收货城市 比较(endswith)
   */
  private String warehouseWarehouseLogisticsCityEndswith;
  /**
   * 收货城市 比较(isnull)
   */
  private Boolean warehouseWarehouseLogisticsCityIsnull;
  /**
   * 收货城市 比较(isnotnull)
   */
  private Boolean warehouseWarehouseLogisticsCityIsnotnull;

  /**
   * 收货城市(精确搜索)
   */
  private List<String> warehouseWarehouseLogisticsCityInList;

  /**
   * 收货邮编开头(模糊搜索)
   */
  private String warehouseWarehouseLogisticsPostCodeStart;

  /**
   * 收货邮编开头 比较(eq)
   */
  private String warehouseWarehouseLogisticsPostCodeStartEq;
  /**
   * 收货邮编开头 比较(neq)
   */
  private String warehouseWarehouseLogisticsPostCodeStartNeq;
  /**
   * 收货邮编开头 比较(gt)
   */
  private String warehouseWarehouseLogisticsPostCodeStartGt;
  /**
   * 收货邮编开头 比较(gte)
   */
  private String warehouseWarehouseLogisticsPostCodeStartGte;
  /**
   * 收货邮编开头 比较(lt)
   */
  private String warehouseWarehouseLogisticsPostCodeStartLt;
  /**
   * 收货邮编开头 比较(lte)
   */
  private String warehouseWarehouseLogisticsPostCodeStartLte;
  /**
   * 收货邮编开头 比较(contains)
   */
  private String warehouseWarehouseLogisticsPostCodeStartContains;
  /**
   * 收货邮编开头 比较(notcontains)
   */
  private String warehouseWarehouseLogisticsPostCodeStartNotcontains;
  /**
   * 收货邮编开头 比较(startswith)
   */
  private String warehouseWarehouseLogisticsPostCodeStartStartswith;
  /**
   * 收货邮编开头 比较(endswith)
   */
  private String warehouseWarehouseLogisticsPostCodeStartEndswith;
  /**
   * 收货邮编开头 比较(isnull)
   */
  private Boolean warehouseWarehouseLogisticsPostCodeStartIsnull;
  /**
   * 收货邮编开头 比较(isnotnull)
   */
  private Boolean warehouseWarehouseLogisticsPostCodeStartIsnotnull;

  /**
   * 收货邮编开头(精确搜索)
   */
  private List<String> warehouseWarehouseLogisticsPostCodeStartInList;

  /**
   * 收货邮编包含(模糊搜索)
   */
  private String warehouseWarehouseLogisticsContains;

  /**
   * 收货邮编包含 比较(eq)
   */
  private String warehouseWarehouseLogisticsContainsEq;
  /**
   * 收货邮编包含 比较(neq)
   */
  private String warehouseWarehouseLogisticsContainsNeq;
  /**
   * 收货邮编包含 比较(gt)
   */
  private String warehouseWarehouseLogisticsContainsGt;
  /**
   * 收货邮编包含 比较(gte)
   */
  private String warehouseWarehouseLogisticsContainsGte;
  /**
   * 收货邮编包含 比较(lt)
   */
  private String warehouseWarehouseLogisticsContainsLt;
  /**
   * 收货邮编包含 比较(lte)
   */
  private String warehouseWarehouseLogisticsContainsLte;
  /**
   * 收货邮编包含 比较(contains)
   */
  private String warehouseWarehouseLogisticsContainsContains;
  /**
   * 收货邮编包含 比较(notcontains)
   */
  private String warehouseWarehouseLogisticsContainsNotcontains;
  /**
   * 收货邮编包含 比较(startswith)
   */
  private String warehouseWarehouseLogisticsContainsStartswith;
  /**
   * 收货邮编包含 比较(endswith)
   */
  private String warehouseWarehouseLogisticsContainsEndswith;
  /**
   * 收货邮编包含 比较(isnull)
   */
  private Boolean warehouseWarehouseLogisticsContainsIsnull;
  /**
   * 收货邮编包含 比较(isnotnull)
   */
  private Boolean warehouseWarehouseLogisticsContainsIsnotnull;

  /**
   * 收货邮编包含(精确搜索)
   */
  private List<String> warehouseWarehouseLogisticsContainsInList;

  /**
   * 两项满足其中一项
   */
  private String warehouseWarehouseLogisticsChooseOne;

  /**
   * 两项满足其中一项 比较(eq)
   */
  private String warehouseWarehouseLogisticsChooseOneEq;
  /**
   * 两项满足其中一项 比较(neq)
   */
  private String warehouseWarehouseLogisticsChooseOneNeq;
  /**
   * 两项满足其中一项 比较(gt)
   */
  private String warehouseWarehouseLogisticsChooseOneGt;
  /**
   * 两项满足其中一项 比较(gte)
   */
  private String warehouseWarehouseLogisticsChooseOneGte;
  /**
   * 两项满足其中一项 比较(lt)
   */
  private String warehouseWarehouseLogisticsChooseOneLt;
  /**
   * 两项满足其中一项 比较(lte)
   */
  private String warehouseWarehouseLogisticsChooseOneLte;
  /**
   * 两项满足其中一项 比较(contains)
   */
  private String warehouseWarehouseLogisticsChooseOneContains;
  /**
   * 两项满足其中一项 比较(notcontains)
   */
  private String warehouseWarehouseLogisticsChooseOneNotcontains;
  /**
   * 两项满足其中一项 比较(startswith)
   */
  private String warehouseWarehouseLogisticsChooseOneStartswith;
  /**
   * 两项满足其中一项 比较(endswith)
   */
  private String warehouseWarehouseLogisticsChooseOneEndswith;
  /**
   * 两项满足其中一项 比较(isnull)
   */
  private Boolean warehouseWarehouseLogisticsChooseOneIsnull;
  /**
   * 两项满足其中一项 比较(isnotnull)
   */
  private Boolean warehouseWarehouseLogisticsChooseOneIsnotnull;

  /**
   * 两项满足其中一项(精确搜索)
   */
  private List<String> warehouseWarehouseLogisticsChooseOneInList;

  /**
   * 指定收货邮编(模糊搜索)
   */
  private String warehouseWarehouseLogisticsWhite;

  /**
   * 指定收货邮编 比较(eq)
   */
  private String warehouseWarehouseLogisticsWhiteEq;
  /**
   * 指定收货邮编 比较(neq)
   */
  private String warehouseWarehouseLogisticsWhiteNeq;
  /**
   * 指定收货邮编 比较(gt)
   */
  private String warehouseWarehouseLogisticsWhiteGt;
  /**
   * 指定收货邮编 比较(gte)
   */
  private String warehouseWarehouseLogisticsWhiteGte;
  /**
   * 指定收货邮编 比较(lt)
   */
  private String warehouseWarehouseLogisticsWhiteLt;
  /**
   * 指定收货邮编 比较(lte)
   */
  private String warehouseWarehouseLogisticsWhiteLte;
  /**
   * 指定收货邮编 比较(contains)
   */
  private String warehouseWarehouseLogisticsWhiteContains;
  /**
   * 指定收货邮编 比较(notcontains)
   */
  private String warehouseWarehouseLogisticsWhiteNotcontains;
  /**
   * 指定收货邮编 比较(startswith)
   */
  private String warehouseWarehouseLogisticsWhiteStartswith;
  /**
   * 指定收货邮编 比较(endswith)
   */
  private String warehouseWarehouseLogisticsWhiteEndswith;
  /**
   * 指定收货邮编 比较(isnull)
   */
  private Boolean warehouseWarehouseLogisticsWhiteIsnull;
  /**
   * 指定收货邮编 比较(isnotnull)
   */
  private Boolean warehouseWarehouseLogisticsWhiteIsnotnull;

  /**
   * 指定收货邮编(精确搜索)
   */
  private List<String> warehouseWarehouseLogisticsWhiteInList;

  /**
   * 排除收货邮编(模糊搜索)
   */
  private String warehouseWarehouseLogisticsBlack;

  /**
   * 排除收货邮编 比较(eq)
   */
  private String warehouseWarehouseLogisticsBlackEq;
  /**
   * 排除收货邮编 比较(neq)
   */
  private String warehouseWarehouseLogisticsBlackNeq;
  /**
   * 排除收货邮编 比较(gt)
   */
  private String warehouseWarehouseLogisticsBlackGt;
  /**
   * 排除收货邮编 比较(gte)
   */
  private String warehouseWarehouseLogisticsBlackGte;
  /**
   * 排除收货邮编 比较(lt)
   */
  private String warehouseWarehouseLogisticsBlackLt;
  /**
   * 排除收货邮编 比较(lte)
   */
  private String warehouseWarehouseLogisticsBlackLte;
  /**
   * 排除收货邮编 比较(contains)
   */
  private String warehouseWarehouseLogisticsBlackContains;
  /**
   * 排除收货邮编 比较(notcontains)
   */
  private String warehouseWarehouseLogisticsBlackNotcontains;
  /**
   * 排除收货邮编 比较(startswith)
   */
  private String warehouseWarehouseLogisticsBlackStartswith;
  /**
   * 排除收货邮编 比较(endswith)
   */
  private String warehouseWarehouseLogisticsBlackEndswith;
  /**
   * 排除收货邮编 比较(isnull)
   */
  private Boolean warehouseWarehouseLogisticsBlackIsnull;
  /**
   * 排除收货邮编 比较(isnotnull)
   */
  private Boolean warehouseWarehouseLogisticsBlackIsnotnull;

  /**
   * 排除收货邮编(精确搜索)
   */
  private List<String> warehouseWarehouseLogisticsBlackInList;

  /**
   * 地址类型
   */
  private String warehouseWarehouseLogisticsAddressType;

  /**
   * 地址类型 比较(eq)
   */
  private String warehouseWarehouseLogisticsAddressTypeEq;
  /**
   * 地址类型 比较(neq)
   */
  private String warehouseWarehouseLogisticsAddressTypeNeq;
  /**
   * 地址类型 比较(gt)
   */
  private String warehouseWarehouseLogisticsAddressTypeGt;
  /**
   * 地址类型 比较(gte)
   */
  private String warehouseWarehouseLogisticsAddressTypeGte;
  /**
   * 地址类型 比较(lt)
   */
  private String warehouseWarehouseLogisticsAddressTypeLt;
  /**
   * 地址类型 比较(lte)
   */
  private String warehouseWarehouseLogisticsAddressTypeLte;
  /**
   * 地址类型 比较(contains)
   */
  private String warehouseWarehouseLogisticsAddressTypeContains;
  /**
   * 地址类型 比较(notcontains)
   */
  private String warehouseWarehouseLogisticsAddressTypeNotcontains;
  /**
   * 地址类型 比较(startswith)
   */
  private String warehouseWarehouseLogisticsAddressTypeStartswith;
  /**
   * 地址类型 比较(endswith)
   */
  private String warehouseWarehouseLogisticsAddressTypeEndswith;
  /**
   * 地址类型 比较(isnull)
   */
  private Boolean warehouseWarehouseLogisticsAddressTypeIsnull;
  /**
   * 地址类型 比较(isnotnull)
   */
  private Boolean warehouseWarehouseLogisticsAddressTypeIsnotnull;

  /**
   * 地址类型(精确搜索)
   */
  private List<String> warehouseWarehouseLogisticsAddressTypeInList;

  /**
   * 订单MSKU(模糊搜索)
   */
  private String warehouseOrderMsku;

  /**
   * 订单MSKU 比较(eq)
   */
  private String warehouseOrderMskuEq;
  /**
   * 订单MSKU 比较(neq)
   */
  private String warehouseOrderMskuNeq;
  /**
   * 订单MSKU 比较(gt)
   */
  private String warehouseOrderMskuGt;
  /**
   * 订单MSKU 比较(gte)
   */
  private String warehouseOrderMskuGte;
  /**
   * 订单MSKU 比较(lt)
   */
  private String warehouseOrderMskuLt;
  /**
   * 订单MSKU 比较(lte)
   */
  private String warehouseOrderMskuLte;
  /**
   * 订单MSKU 比较(contains)
   */
  private String warehouseOrderMskuContains;
  /**
   * 订单MSKU 比较(notcontains)
   */
  private String warehouseOrderMskuNotcontains;
  /**
   * 订单MSKU 比较(startswith)
   */
  private String warehouseOrderMskuStartswith;
  /**
   * 订单MSKU 比较(endswith)
   */
  private String warehouseOrderMskuEndswith;
  /**
   * 订单MSKU 比较(isnull)
   */
  private Boolean warehouseOrderMskuIsnull;
  /**
   * 订单MSKU 比较(isnotnull)
   */
  private Boolean warehouseOrderMskuIsnotnull;

  /**
   * 订单MSKU(精确搜索)
   */
  private List<String> warehouseOrderMskuInList;

  /**
   * 订单产品
   */
  private Long warehouseOrderProduct;

  /**
   * 订单产品 比较(eq)
   */
  private Long warehouseOrderProductEq;
  /**
   * 订单产品 比较(neq)
   */
  private Long warehouseOrderProductNeq;
  /**
   * 订单产品 比较(gt)
   */
  private Long warehouseOrderProductGt;
  /**
   * 订单产品 比较(gte)
   */
  private Long warehouseOrderProductGte;
  /**
   * 订单产品 比较(lt)
   */
  private Long warehouseOrderProductLt;
  /**
   * 订单产品 比较(lte)
   */
  private Long warehouseOrderProductLte;
  /**
   * 订单产品 比较(contains)
   */
  private Long warehouseOrderProductContains;
  /**
   * 订单产品 比较(notcontains)
   */
  private Long warehouseOrderProductNotcontains;
  /**
   * 订单产品 比较(startswith)
   */
  private Long warehouseOrderProductStartswith;
  /**
   * 订单产品 比较(endswith)
   */
  private Long warehouseOrderProductEndswith;
  /**
   * 订单产品 比较(isnull)
   */
  private Boolean warehouseOrderProductIsnull;
  /**
   * 订单产品 比较(isnotnull)
   */
  private Boolean warehouseOrderProductIsnotnull;
  /**
   * 订单产品的品名 比较(eq)
   */
  private String warehouseOrderProductNameEq;
  /**
   * 订单产品的品名 比较(neq)
   */
  private String warehouseOrderProductNameNeq;
  /**
   * 订单产品的品名 比较(gt)
   */
  private String warehouseOrderProductNameGt;
  /**
   * 订单产品的品名 比较(gte)
   */
  private String warehouseOrderProductNameGte;
  /**
   * 订单产品的品名 比较(lt)
   */
  private String warehouseOrderProductNameLt;
  /**
   * 订单产品的品名 比较(lte)
   */
  private String warehouseOrderProductNameLte;
  /**
   * 订单产品的品名 比较(contains)
   */
  private String warehouseOrderProductNameContains;
  /**
   * 订单产品的品名 比较(notcontains)
   */
  private String warehouseOrderProductNameNotcontains;
  /**
   * 订单产品的品名 比较(startswith)
   */
  private String warehouseOrderProductNameStartswith;
  /**
   * 订单产品的品名 比较(endswith)
   */
  private String warehouseOrderProductNameEndswith;
  /**
   * 订单产品的品名 比较(isnull)
   */
  private Boolean warehouseOrderProductNameIsnull;
  /**
   * 订单产品的品名 比较(isnotnull)
   */
  private Boolean warehouseOrderProductNameIsnotnull;

  /**
   * 产品分类
   */
  private Long warehouseOrderProductClassify;

  /**
   * 产品分类 比较(eq)
   */
  private Long warehouseOrderProductClassifyEq;
  /**
   * 产品分类 比较(neq)
   */
  private Long warehouseOrderProductClassifyNeq;
  /**
   * 产品分类 比较(gt)
   */
  private Long warehouseOrderProductClassifyGt;
  /**
   * 产品分类 比较(gte)
   */
  private Long warehouseOrderProductClassifyGte;
  /**
   * 产品分类 比较(lt)
   */
  private Long warehouseOrderProductClassifyLt;
  /**
   * 产品分类 比较(lte)
   */
  private Long warehouseOrderProductClassifyLte;
  /**
   * 产品分类 比较(contains)
   */
  private Long warehouseOrderProductClassifyContains;
  /**
   * 产品分类 比较(notcontains)
   */
  private Long warehouseOrderProductClassifyNotcontains;
  /**
   * 产品分类 比较(startswith)
   */
  private Long warehouseOrderProductClassifyStartswith;
  /**
   * 产品分类 比较(endswith)
   */
  private Long warehouseOrderProductClassifyEndswith;
  /**
   * 产品分类 比较(isnull)
   */
  private Boolean warehouseOrderProductClassifyIsnull;
  /**
   * 产品分类 比较(isnotnull)
   */
  private Boolean warehouseOrderProductClassifyIsnotnull;
  /**
   * 产品分类的分类名称 比较(eq)
   */
  private String warehouseOrderProductClassifyNameEq;
  /**
   * 产品分类的分类名称 比较(neq)
   */
  private String warehouseOrderProductClassifyNameNeq;
  /**
   * 产品分类的分类名称 比较(gt)
   */
  private String warehouseOrderProductClassifyNameGt;
  /**
   * 产品分类的分类名称 比较(gte)
   */
  private String warehouseOrderProductClassifyNameGte;
  /**
   * 产品分类的分类名称 比较(lt)
   */
  private String warehouseOrderProductClassifyNameLt;
  /**
   * 产品分类的分类名称 比较(lte)
   */
  private String warehouseOrderProductClassifyNameLte;
  /**
   * 产品分类的分类名称 比较(contains)
   */
  private String warehouseOrderProductClassifyNameContains;
  /**
   * 产品分类的分类名称 比较(notcontains)
   */
  private String warehouseOrderProductClassifyNameNotcontains;
  /**
   * 产品分类的分类名称 比较(startswith)
   */
  private String warehouseOrderProductClassifyNameStartswith;
  /**
   * 产品分类的分类名称 比较(endswith)
   */
  private String warehouseOrderProductClassifyNameEndswith;
  /**
   * 产品分类的分类名称 比较(isnull)
   */
  private Boolean warehouseOrderProductClassifyNameIsnull;
  /**
   * 产品分类的分类名称 比较(isnotnull)
   */
  private Boolean warehouseOrderProductClassifyNameIsnotnull;

  /**
   * 客选物流
   */
  private Long warehouseOrderLogistics;

  /**
   * 客选物流 比较(eq)
   */
  private Long warehouseOrderLogisticsEq;
  /**
   * 客选物流 比较(neq)
   */
  private Long warehouseOrderLogisticsNeq;
  /**
   * 客选物流 比较(gt)
   */
  private Long warehouseOrderLogisticsGt;
  /**
   * 客选物流 比较(gte)
   */
  private Long warehouseOrderLogisticsGte;
  /**
   * 客选物流 比较(lt)
   */
  private Long warehouseOrderLogisticsLt;
  /**
   * 客选物流 比较(lte)
   */
  private Long warehouseOrderLogisticsLte;
  /**
   * 客选物流 比较(contains)
   */
  private Long warehouseOrderLogisticsContains;
  /**
   * 客选物流 比较(notcontains)
   */
  private Long warehouseOrderLogisticsNotcontains;
  /**
   * 客选物流 比较(startswith)
   */
  private Long warehouseOrderLogisticsStartswith;
  /**
   * 客选物流 比较(endswith)
   */
  private Long warehouseOrderLogisticsEndswith;
  /**
   * 客选物流 比较(isnull)
   */
  private Boolean warehouseOrderLogisticsIsnull;
  /**
   * 客选物流 比较(isnotnull)
   */
  private Boolean warehouseOrderLogisticsIsnotnull;
  /**
   * 客选物流的名称 比较(eq)
   */
  private String warehouseOrderLogisticsLabelEq;
  /**
   * 客选物流的名称 比较(neq)
   */
  private String warehouseOrderLogisticsLabelNeq;
  /**
   * 客选物流的名称 比较(gt)
   */
  private String warehouseOrderLogisticsLabelGt;
  /**
   * 客选物流的名称 比较(gte)
   */
  private String warehouseOrderLogisticsLabelGte;
  /**
   * 客选物流的名称 比较(lt)
   */
  private String warehouseOrderLogisticsLabelLt;
  /**
   * 客选物流的名称 比较(lte)
   */
  private String warehouseOrderLogisticsLabelLte;
  /**
   * 客选物流的名称 比较(contains)
   */
  private String warehouseOrderLogisticsLabelContains;
  /**
   * 客选物流的名称 比较(notcontains)
   */
  private String warehouseOrderLogisticsLabelNotcontains;
  /**
   * 客选物流的名称 比较(startswith)
   */
  private String warehouseOrderLogisticsLabelStartswith;
  /**
   * 客选物流的名称 比较(endswith)
   */
  private String warehouseOrderLogisticsLabelEndswith;
  /**
   * 客选物流的名称 比较(isnull)
   */
  private Boolean warehouseOrderLogisticsLabelIsnull;
  /**
   * 客选物流的名称 比较(isnotnull)
   */
  private Boolean warehouseOrderLogisticsLabelIsnotnull;

  /**
   * 特殊属性
   */
  private String warehouseOrderSpecial;

  /**
   * 特殊属性 比较(eq)
   */
  private String warehouseOrderSpecialEq;
  /**
   * 特殊属性 比较(neq)
   */
  private String warehouseOrderSpecialNeq;
  /**
   * 特殊属性 比较(gt)
   */
  private String warehouseOrderSpecialGt;
  /**
   * 特殊属性 比较(gte)
   */
  private String warehouseOrderSpecialGte;
  /**
   * 特殊属性 比较(lt)
   */
  private String warehouseOrderSpecialLt;
  /**
   * 特殊属性 比较(lte)
   */
  private String warehouseOrderSpecialLte;
  /**
   * 特殊属性 比较(contains)
   */
  private String warehouseOrderSpecialContains;
  /**
   * 特殊属性 比较(notcontains)
   */
  private String warehouseOrderSpecialNotcontains;
  /**
   * 特殊属性 比较(startswith)
   */
  private String warehouseOrderSpecialStartswith;
  /**
   * 特殊属性 比较(endswith)
   */
  private String warehouseOrderSpecialEndswith;
  /**
   * 特殊属性 比较(isnull)
   */
  private Boolean warehouseOrderSpecialIsnull;
  /**
   * 特殊属性 比较(isnotnull)
   */
  private Boolean warehouseOrderSpecialIsnotnull;

  /**
   * 特殊属性(精确搜索)
   */
  private List<String> warehouseOrderSpecialInList;

  /**
   * 毛利润率(模糊搜索)
   */
  private String warehouseOrderGrossMargin;

  /**
   * 毛利润率 比较(eq)
   */
  private String warehouseOrderGrossMarginEq;
  /**
   * 毛利润率 比较(neq)
   */
  private String warehouseOrderGrossMarginNeq;
  /**
   * 毛利润率 比较(gt)
   */
  private String warehouseOrderGrossMarginGt;
  /**
   * 毛利润率 比较(gte)
   */
  private String warehouseOrderGrossMarginGte;
  /**
   * 毛利润率 比较(lt)
   */
  private String warehouseOrderGrossMarginLt;
  /**
   * 毛利润率 比较(lte)
   */
  private String warehouseOrderGrossMarginLte;
  /**
   * 毛利润率 比较(contains)
   */
  private String warehouseOrderGrossMarginContains;
  /**
   * 毛利润率 比较(notcontains)
   */
  private String warehouseOrderGrossMarginNotcontains;
  /**
   * 毛利润率 比较(startswith)
   */
  private String warehouseOrderGrossMarginStartswith;
  /**
   * 毛利润率 比较(endswith)
   */
  private String warehouseOrderGrossMarginEndswith;
  /**
   * 毛利润率 比较(isnull)
   */
  private Boolean warehouseOrderGrossMarginIsnull;
  /**
   * 毛利润率 比较(isnotnull)
   */
  private Boolean warehouseOrderGrossMarginIsnotnull;

  /**
   * 毛利润率(精确搜索)
   */
  private List<String> warehouseOrderGrossMarginInList;

  /**
   * 发货仓库
   */
  private Long warehouseActDeliveryWarehouse;

  /**
   * 发货仓库 比较(eq)
   */
  private Long warehouseActDeliveryWarehouseEq;
  /**
   * 发货仓库 比较(neq)
   */
  private Long warehouseActDeliveryWarehouseNeq;
  /**
   * 发货仓库 比较(gt)
   */
  private Long warehouseActDeliveryWarehouseGt;
  /**
   * 发货仓库 比较(gte)
   */
  private Long warehouseActDeliveryWarehouseGte;
  /**
   * 发货仓库 比较(lt)
   */
  private Long warehouseActDeliveryWarehouseLt;
  /**
   * 发货仓库 比较(lte)
   */
  private Long warehouseActDeliveryWarehouseLte;
  /**
   * 发货仓库 比较(contains)
   */
  private Long warehouseActDeliveryWarehouseContains;
  /**
   * 发货仓库 比较(notcontains)
   */
  private Long warehouseActDeliveryWarehouseNotcontains;
  /**
   * 发货仓库 比较(startswith)
   */
  private Long warehouseActDeliveryWarehouseStartswith;
  /**
   * 发货仓库 比较(endswith)
   */
  private Long warehouseActDeliveryWarehouseEndswith;
  /**
   * 发货仓库 比较(isnull)
   */
  private Boolean warehouseActDeliveryWarehouseIsnull;
  /**
   * 发货仓库 比较(isnotnull)
   */
  private Boolean warehouseActDeliveryWarehouseIsnotnull;
  /**
   * 发货仓库的仓库名称 比较(eq)
   */
  private String warehouseActDeliveryWarehouseNameEq;
  /**
   * 发货仓库的仓库名称 比较(neq)
   */
  private String warehouseActDeliveryWarehouseNameNeq;
  /**
   * 发货仓库的仓库名称 比较(gt)
   */
  private String warehouseActDeliveryWarehouseNameGt;
  /**
   * 发货仓库的仓库名称 比较(gte)
   */
  private String warehouseActDeliveryWarehouseNameGte;
  /**
   * 发货仓库的仓库名称 比较(lt)
   */
  private String warehouseActDeliveryWarehouseNameLt;
  /**
   * 发货仓库的仓库名称 比较(lte)
   */
  private String warehouseActDeliveryWarehouseNameLte;
  /**
   * 发货仓库的仓库名称 比较(contains)
   */
  private String warehouseActDeliveryWarehouseNameContains;
  /**
   * 发货仓库的仓库名称 比较(notcontains)
   */
  private String warehouseActDeliveryWarehouseNameNotcontains;
  /**
   * 发货仓库的仓库名称 比较(startswith)
   */
  private String warehouseActDeliveryWarehouseNameStartswith;
  /**
   * 发货仓库的仓库名称 比较(endswith)
   */
  private String warehouseActDeliveryWarehouseNameEndswith;
  /**
   * 发货仓库的仓库名称 比较(isnull)
   */
  private Boolean warehouseActDeliveryWarehouseNameIsnull;
  /**
   * 发货仓库的仓库名称 比较(isnotnull)
   */
  private Boolean warehouseActDeliveryWarehouseNameIsnotnull;

  /**
   * 发货仓库(范围搜索)
   */
  private List<Long> warehouseActDeliveryWarehouseInList;

  /**
   * 备选仓库
   */
  private Long warehouseActOptionWarehouse;

  /**
   * 备选仓库 比较(eq)
   */
  private Long warehouseActOptionWarehouseEq;
  /**
   * 备选仓库 比较(neq)
   */
  private Long warehouseActOptionWarehouseNeq;
  /**
   * 备选仓库 比较(gt)
   */
  private Long warehouseActOptionWarehouseGt;
  /**
   * 备选仓库 比较(gte)
   */
  private Long warehouseActOptionWarehouseGte;
  /**
   * 备选仓库 比较(lt)
   */
  private Long warehouseActOptionWarehouseLt;
  /**
   * 备选仓库 比较(lte)
   */
  private Long warehouseActOptionWarehouseLte;
  /**
   * 备选仓库 比较(contains)
   */
  private Long warehouseActOptionWarehouseContains;
  /**
   * 备选仓库 比较(notcontains)
   */
  private Long warehouseActOptionWarehouseNotcontains;
  /**
   * 备选仓库 比较(startswith)
   */
  private Long warehouseActOptionWarehouseStartswith;
  /**
   * 备选仓库 比较(endswith)
   */
  private Long warehouseActOptionWarehouseEndswith;
  /**
   * 备选仓库 比较(isnull)
   */
  private Boolean warehouseActOptionWarehouseIsnull;
  /**
   * 备选仓库 比较(isnotnull)
   */
  private Boolean warehouseActOptionWarehouseIsnotnull;
  /**
   * 备选仓库的仓库名称 比较(eq)
   */
  private String warehouseActOptionWarehouseNameEq;
  /**
   * 备选仓库的仓库名称 比较(neq)
   */
  private String warehouseActOptionWarehouseNameNeq;
  /**
   * 备选仓库的仓库名称 比较(gt)
   */
  private String warehouseActOptionWarehouseNameGt;
  /**
   * 备选仓库的仓库名称 比较(gte)
   */
  private String warehouseActOptionWarehouseNameGte;
  /**
   * 备选仓库的仓库名称 比较(lt)
   */
  private String warehouseActOptionWarehouseNameLt;
  /**
   * 备选仓库的仓库名称 比较(lte)
   */
  private String warehouseActOptionWarehouseNameLte;
  /**
   * 备选仓库的仓库名称 比较(contains)
   */
  private String warehouseActOptionWarehouseNameContains;
  /**
   * 备选仓库的仓库名称 比较(notcontains)
   */
  private String warehouseActOptionWarehouseNameNotcontains;
  /**
   * 备选仓库的仓库名称 比较(startswith)
   */
  private String warehouseActOptionWarehouseNameStartswith;
  /**
   * 备选仓库的仓库名称 比较(endswith)
   */
  private String warehouseActOptionWarehouseNameEndswith;
  /**
   * 备选仓库的仓库名称 比较(isnull)
   */
  private Boolean warehouseActOptionWarehouseNameIsnull;
  /**
   * 备选仓库的仓库名称 比较(isnotnull)
   */
  private Boolean warehouseActOptionWarehouseNameIsnotnull;

  /**
   * 自动覆盖订单原有仓库
   */
  private String warehouseActAutoCoverOriginal;

  /**
   * 自动覆盖订单原有仓库 比较(eq)
   */
  private String warehouseActAutoCoverOriginalEq;
  /**
   * 自动覆盖订单原有仓库 比较(neq)
   */
  private String warehouseActAutoCoverOriginalNeq;
  /**
   * 自动覆盖订单原有仓库 比较(gt)
   */
  private String warehouseActAutoCoverOriginalGt;
  /**
   * 自动覆盖订单原有仓库 比较(gte)
   */
  private String warehouseActAutoCoverOriginalGte;
  /**
   * 自动覆盖订单原有仓库 比较(lt)
   */
  private String warehouseActAutoCoverOriginalLt;
  /**
   * 自动覆盖订单原有仓库 比较(lte)
   */
  private String warehouseActAutoCoverOriginalLte;
  /**
   * 自动覆盖订单原有仓库 比较(contains)
   */
  private String warehouseActAutoCoverOriginalContains;
  /**
   * 自动覆盖订单原有仓库 比较(notcontains)
   */
  private String warehouseActAutoCoverOriginalNotcontains;
  /**
   * 自动覆盖订单原有仓库 比较(startswith)
   */
  private String warehouseActAutoCoverOriginalStartswith;
  /**
   * 自动覆盖订单原有仓库 比较(endswith)
   */
  private String warehouseActAutoCoverOriginalEndswith;
  /**
   * 自动覆盖订单原有仓库 比较(isnull)
   */
  private Boolean warehouseActAutoCoverOriginalIsnull;
  /**
   * 自动覆盖订单原有仓库 比较(isnotnull)
   */
  private Boolean warehouseActAutoCoverOriginalIsnotnull;

  /**
   * 自动覆盖订单原有仓库(精确搜索)
   */
  private List<String> warehouseActAutoCoverOriginalInList;

  /**
   * 库存扣减类型
   */
  private String warehouseActInventoryDeductionType;

  /**
   * 库存扣减类型 比较(eq)
   */
  private String warehouseActInventoryDeductionTypeEq;
  /**
   * 库存扣减类型 比较(neq)
   */
  private String warehouseActInventoryDeductionTypeNeq;
  /**
   * 库存扣减类型 比较(gt)
   */
  private String warehouseActInventoryDeductionTypeGt;
  /**
   * 库存扣减类型 比较(gte)
   */
  private String warehouseActInventoryDeductionTypeGte;
  /**
   * 库存扣减类型 比较(lt)
   */
  private String warehouseActInventoryDeductionTypeLt;
  /**
   * 库存扣减类型 比较(lte)
   */
  private String warehouseActInventoryDeductionTypeLte;
  /**
   * 库存扣减类型 比较(contains)
   */
  private String warehouseActInventoryDeductionTypeContains;
  /**
   * 库存扣减类型 比较(notcontains)
   */
  private String warehouseActInventoryDeductionTypeNotcontains;
  /**
   * 库存扣减类型 比较(startswith)
   */
  private String warehouseActInventoryDeductionTypeStartswith;
  /**
   * 库存扣减类型 比较(endswith)
   */
  private String warehouseActInventoryDeductionTypeEndswith;
  /**
   * 库存扣减类型 比较(isnull)
   */
  private Boolean warehouseActInventoryDeductionTypeIsnull;
  /**
   * 库存扣减类型 比较(isnotnull)
   */
  private Boolean warehouseActInventoryDeductionTypeIsnotnull;

  /**
   * 库存扣减类型(精确搜索)
   */
  private List<String> warehouseActInventoryDeductionTypeInList;

  /**
   * 订单平台
   */
  private String logisticsBaseOrderPlatform;

  /**
   * 订单平台 比较(eq)
   */
  private String logisticsBaseOrderPlatformEq;
  /**
   * 订单平台 比较(neq)
   */
  private String logisticsBaseOrderPlatformNeq;
  /**
   * 订单平台 比较(gt)
   */
  private String logisticsBaseOrderPlatformGt;
  /**
   * 订单平台 比较(gte)
   */
  private String logisticsBaseOrderPlatformGte;
  /**
   * 订单平台 比较(lt)
   */
  private String logisticsBaseOrderPlatformLt;
  /**
   * 订单平台 比较(lte)
   */
  private String logisticsBaseOrderPlatformLte;
  /**
   * 订单平台 比较(contains)
   */
  private String logisticsBaseOrderPlatformContains;
  /**
   * 订单平台 比较(notcontains)
   */
  private String logisticsBaseOrderPlatformNotcontains;
  /**
   * 订单平台 比较(startswith)
   */
  private String logisticsBaseOrderPlatformStartswith;
  /**
   * 订单平台 比较(endswith)
   */
  private String logisticsBaseOrderPlatformEndswith;
  /**
   * 订单平台 比较(isnull)
   */
  private Boolean logisticsBaseOrderPlatformIsnull;
  /**
   * 订单平台 比较(isnotnull)
   */
  private Boolean logisticsBaseOrderPlatformIsnotnull;

  /**
   * 订单平台(精确搜索)
   */
  private List<String> logisticsBaseOrderPlatformInList;

  /**
   * 订单站点
   */
  private Long logisticsBaseOrderSite;

  /**
   * 订单站点 比较(eq)
   */
  private Long logisticsBaseOrderSiteEq;
  /**
   * 订单站点 比较(neq)
   */
  private Long logisticsBaseOrderSiteNeq;
  /**
   * 订单站点 比较(gt)
   */
  private Long logisticsBaseOrderSiteGt;
  /**
   * 订单站点 比较(gte)
   */
  private Long logisticsBaseOrderSiteGte;
  /**
   * 订单站点 比较(lt)
   */
  private Long logisticsBaseOrderSiteLt;
  /**
   * 订单站点 比较(lte)
   */
  private Long logisticsBaseOrderSiteLte;
  /**
   * 订单站点 比较(contains)
   */
  private Long logisticsBaseOrderSiteContains;
  /**
   * 订单站点 比较(notcontains)
   */
  private Long logisticsBaseOrderSiteNotcontains;
  /**
   * 订单站点 比较(startswith)
   */
  private Long logisticsBaseOrderSiteStartswith;
  /**
   * 订单站点 比较(endswith)
   */
  private Long logisticsBaseOrderSiteEndswith;
  /**
   * 订单站点 比较(isnull)
   */
  private Boolean logisticsBaseOrderSiteIsnull;
  /**
   * 订单站点 比较(isnotnull)
   */
  private Boolean logisticsBaseOrderSiteIsnotnull;
  /**
   * 订单站点的名称 比较(eq)
   */
  private String logisticsBaseOrderSiteNameEq;
  /**
   * 订单站点的名称 比较(neq)
   */
  private String logisticsBaseOrderSiteNameNeq;
  /**
   * 订单站点的名称 比较(gt)
   */
  private String logisticsBaseOrderSiteNameGt;
  /**
   * 订单站点的名称 比较(gte)
   */
  private String logisticsBaseOrderSiteNameGte;
  /**
   * 订单站点的名称 比较(lt)
   */
  private String logisticsBaseOrderSiteNameLt;
  /**
   * 订单站点的名称 比较(lte)
   */
  private String logisticsBaseOrderSiteNameLte;
  /**
   * 订单站点的名称 比较(contains)
   */
  private String logisticsBaseOrderSiteNameContains;
  /**
   * 订单站点的名称 比较(notcontains)
   */
  private String logisticsBaseOrderSiteNameNotcontains;
  /**
   * 订单站点的名称 比较(startswith)
   */
  private String logisticsBaseOrderSiteNameStartswith;
  /**
   * 订单站点的名称 比较(endswith)
   */
  private String logisticsBaseOrderSiteNameEndswith;
  /**
   * 订单站点的名称 比较(isnull)
   */
  private Boolean logisticsBaseOrderSiteNameIsnull;
  /**
   * 订单站点的名称 比较(isnotnull)
   */
  private Boolean logisticsBaseOrderSiteNameIsnotnull;

  /**
   * 订单店铺
   */
  private Long logisticsBaseOrderShopInfo;

  /**
   * 订单店铺 比较(eq)
   */
  private Long logisticsBaseOrderShopInfoEq;
  /**
   * 订单店铺 比较(neq)
   */
  private Long logisticsBaseOrderShopInfoNeq;
  /**
   * 订单店铺 比较(gt)
   */
  private Long logisticsBaseOrderShopInfoGt;
  /**
   * 订单店铺 比较(gte)
   */
  private Long logisticsBaseOrderShopInfoGte;
  /**
   * 订单店铺 比较(lt)
   */
  private Long logisticsBaseOrderShopInfoLt;
  /**
   * 订单店铺 比较(lte)
   */
  private Long logisticsBaseOrderShopInfoLte;
  /**
   * 订单店铺 比较(contains)
   */
  private Long logisticsBaseOrderShopInfoContains;
  /**
   * 订单店铺 比较(notcontains)
   */
  private Long logisticsBaseOrderShopInfoNotcontains;
  /**
   * 订单店铺 比较(startswith)
   */
  private Long logisticsBaseOrderShopInfoStartswith;
  /**
   * 订单店铺 比较(endswith)
   */
  private Long logisticsBaseOrderShopInfoEndswith;
  /**
   * 订单店铺 比较(isnull)
   */
  private Boolean logisticsBaseOrderShopInfoIsnull;
  /**
   * 订单店铺 比较(isnotnull)
   */
  private Boolean logisticsBaseOrderShopInfoIsnotnull;
  /**
   * 订单店铺的名称 比较(eq)
   */
  private String logisticsBaseOrderShopInfoShopNameEq;
  /**
   * 订单店铺的名称 比较(neq)
   */
  private String logisticsBaseOrderShopInfoShopNameNeq;
  /**
   * 订单店铺的名称 比较(gt)
   */
  private String logisticsBaseOrderShopInfoShopNameGt;
  /**
   * 订单店铺的名称 比较(gte)
   */
  private String logisticsBaseOrderShopInfoShopNameGte;
  /**
   * 订单店铺的名称 比较(lt)
   */
  private String logisticsBaseOrderShopInfoShopNameLt;
  /**
   * 订单店铺的名称 比较(lte)
   */
  private String logisticsBaseOrderShopInfoShopNameLte;
  /**
   * 订单店铺的名称 比较(contains)
   */
  private String logisticsBaseOrderShopInfoShopNameContains;
  /**
   * 订单店铺的名称 比较(notcontains)
   */
  private String logisticsBaseOrderShopInfoShopNameNotcontains;
  /**
   * 订单店铺的名称 比较(startswith)
   */
  private String logisticsBaseOrderShopInfoShopNameStartswith;
  /**
   * 订单店铺的名称 比较(endswith)
   */
  private String logisticsBaseOrderShopInfoShopNameEndswith;
  /**
   * 订单店铺的名称 比较(isnull)
   */
  private Boolean logisticsBaseOrderShopInfoShopNameIsnull;
  /**
   * 订单店铺的名称 比较(isnotnull)
   */
  private Boolean logisticsBaseOrderShopInfoShopNameIsnotnull;

  /**
   * 收货国家/地区
   */
  private Long logisticsWarehouseLogisticsCountry;

  /**
   * 收货国家/地区 比较(eq)
   */
  private Long logisticsWarehouseLogisticsCountryEq;
  /**
   * 收货国家/地区 比较(neq)
   */
  private Long logisticsWarehouseLogisticsCountryNeq;
  /**
   * 收货国家/地区 比较(gt)
   */
  private Long logisticsWarehouseLogisticsCountryGt;
  /**
   * 收货国家/地区 比较(gte)
   */
  private Long logisticsWarehouseLogisticsCountryGte;
  /**
   * 收货国家/地区 比较(lt)
   */
  private Long logisticsWarehouseLogisticsCountryLt;
  /**
   * 收货国家/地区 比较(lte)
   */
  private Long logisticsWarehouseLogisticsCountryLte;
  /**
   * 收货国家/地区 比较(contains)
   */
  private Long logisticsWarehouseLogisticsCountryContains;
  /**
   * 收货国家/地区 比较(notcontains)
   */
  private Long logisticsWarehouseLogisticsCountryNotcontains;
  /**
   * 收货国家/地区 比较(startswith)
   */
  private Long logisticsWarehouseLogisticsCountryStartswith;
  /**
   * 收货国家/地区 比较(endswith)
   */
  private Long logisticsWarehouseLogisticsCountryEndswith;
  /**
   * 收货国家/地区 比较(isnull)
   */
  private Boolean logisticsWarehouseLogisticsCountryIsnull;
  /**
   * 收货国家/地区 比较(isnotnull)
   */
  private Boolean logisticsWarehouseLogisticsCountryIsnotnull;
  /**
   * 收货国家/地区的国家 比较(eq)
   */
  private String logisticsWarehouseLogisticsCountryCountryEq;
  /**
   * 收货国家/地区的国家 比较(neq)
   */
  private String logisticsWarehouseLogisticsCountryCountryNeq;
  /**
   * 收货国家/地区的国家 比较(gt)
   */
  private String logisticsWarehouseLogisticsCountryCountryGt;
  /**
   * 收货国家/地区的国家 比较(gte)
   */
  private String logisticsWarehouseLogisticsCountryCountryGte;
  /**
   * 收货国家/地区的国家 比较(lt)
   */
  private String logisticsWarehouseLogisticsCountryCountryLt;
  /**
   * 收货国家/地区的国家 比较(lte)
   */
  private String logisticsWarehouseLogisticsCountryCountryLte;
  /**
   * 收货国家/地区的国家 比较(contains)
   */
  private String logisticsWarehouseLogisticsCountryCountryContains;
  /**
   * 收货国家/地区的国家 比较(notcontains)
   */
  private String logisticsWarehouseLogisticsCountryCountryNotcontains;
  /**
   * 收货国家/地区的国家 比较(startswith)
   */
  private String logisticsWarehouseLogisticsCountryCountryStartswith;
  /**
   * 收货国家/地区的国家 比较(endswith)
   */
  private String logisticsWarehouseLogisticsCountryCountryEndswith;
  /**
   * 收货国家/地区的国家 比较(isnull)
   */
  private Boolean logisticsWarehouseLogisticsCountryCountryIsnull;
  /**
   * 收货国家/地区的国家 比较(isnotnull)
   */
  private Boolean logisticsWarehouseLogisticsCountryCountryIsnotnull;

  /**
   * 收货省/州(模糊搜索)
   */
  private String logisticsWarehouseLogisticsProvince;

  /**
   * 收货省/州 比较(eq)
   */
  private String logisticsWarehouseLogisticsProvinceEq;
  /**
   * 收货省/州 比较(neq)
   */
  private String logisticsWarehouseLogisticsProvinceNeq;
  /**
   * 收货省/州 比较(gt)
   */
  private String logisticsWarehouseLogisticsProvinceGt;
  /**
   * 收货省/州 比较(gte)
   */
  private String logisticsWarehouseLogisticsProvinceGte;
  /**
   * 收货省/州 比较(lt)
   */
  private String logisticsWarehouseLogisticsProvinceLt;
  /**
   * 收货省/州 比较(lte)
   */
  private String logisticsWarehouseLogisticsProvinceLte;
  /**
   * 收货省/州 比较(contains)
   */
  private String logisticsWarehouseLogisticsProvinceContains;
  /**
   * 收货省/州 比较(notcontains)
   */
  private String logisticsWarehouseLogisticsProvinceNotcontains;
  /**
   * 收货省/州 比较(startswith)
   */
  private String logisticsWarehouseLogisticsProvinceStartswith;
  /**
   * 收货省/州 比较(endswith)
   */
  private String logisticsWarehouseLogisticsProvinceEndswith;
  /**
   * 收货省/州 比较(isnull)
   */
  private Boolean logisticsWarehouseLogisticsProvinceIsnull;
  /**
   * 收货省/州 比较(isnotnull)
   */
  private Boolean logisticsWarehouseLogisticsProvinceIsnotnull;

  /**
   * 收货省/州(精确搜索)
   */
  private List<String> logisticsWarehouseLogisticsProvinceInList;

  /**
   * 收货城市(模糊搜索)
   */
  private String logisticsWarehouseLogisticsCity;

  /**
   * 收货城市 比较(eq)
   */
  private String logisticsWarehouseLogisticsCityEq;
  /**
   * 收货城市 比较(neq)
   */
  private String logisticsWarehouseLogisticsCityNeq;
  /**
   * 收货城市 比较(gt)
   */
  private String logisticsWarehouseLogisticsCityGt;
  /**
   * 收货城市 比较(gte)
   */
  private String logisticsWarehouseLogisticsCityGte;
  /**
   * 收货城市 比较(lt)
   */
  private String logisticsWarehouseLogisticsCityLt;
  /**
   * 收货城市 比较(lte)
   */
  private String logisticsWarehouseLogisticsCityLte;
  /**
   * 收货城市 比较(contains)
   */
  private String logisticsWarehouseLogisticsCityContains;
  /**
   * 收货城市 比较(notcontains)
   */
  private String logisticsWarehouseLogisticsCityNotcontains;
  /**
   * 收货城市 比较(startswith)
   */
  private String logisticsWarehouseLogisticsCityStartswith;
  /**
   * 收货城市 比较(endswith)
   */
  private String logisticsWarehouseLogisticsCityEndswith;
  /**
   * 收货城市 比较(isnull)
   */
  private Boolean logisticsWarehouseLogisticsCityIsnull;
  /**
   * 收货城市 比较(isnotnull)
   */
  private Boolean logisticsWarehouseLogisticsCityIsnotnull;

  /**
   * 收货城市(精确搜索)
   */
  private List<String> logisticsWarehouseLogisticsCityInList;

  /**
   * 收货邮编开头(模糊搜索)
   */
  private String logisticsWarehouseLogisticsPostCodeStart;

  /**
   * 收货邮编开头 比较(eq)
   */
  private String logisticsWarehouseLogisticsPostCodeStartEq;
  /**
   * 收货邮编开头 比较(neq)
   */
  private String logisticsWarehouseLogisticsPostCodeStartNeq;
  /**
   * 收货邮编开头 比较(gt)
   */
  private String logisticsWarehouseLogisticsPostCodeStartGt;
  /**
   * 收货邮编开头 比较(gte)
   */
  private String logisticsWarehouseLogisticsPostCodeStartGte;
  /**
   * 收货邮编开头 比较(lt)
   */
  private String logisticsWarehouseLogisticsPostCodeStartLt;
  /**
   * 收货邮编开头 比较(lte)
   */
  private String logisticsWarehouseLogisticsPostCodeStartLte;
  /**
   * 收货邮编开头 比较(contains)
   */
  private String logisticsWarehouseLogisticsPostCodeStartContains;
  /**
   * 收货邮编开头 比较(notcontains)
   */
  private String logisticsWarehouseLogisticsPostCodeStartNotcontains;
  /**
   * 收货邮编开头 比较(startswith)
   */
  private String logisticsWarehouseLogisticsPostCodeStartStartswith;
  /**
   * 收货邮编开头 比较(endswith)
   */
  private String logisticsWarehouseLogisticsPostCodeStartEndswith;
  /**
   * 收货邮编开头 比较(isnull)
   */
  private Boolean logisticsWarehouseLogisticsPostCodeStartIsnull;
  /**
   * 收货邮编开头 比较(isnotnull)
   */
  private Boolean logisticsWarehouseLogisticsPostCodeStartIsnotnull;

  /**
   * 收货邮编开头(精确搜索)
   */
  private List<String> logisticsWarehouseLogisticsPostCodeStartInList;

  /**
   * 收货邮编包含(模糊搜索)
   */
  private String logisticsWarehouseLogisticsContains;

  /**
   * 收货邮编包含 比较(eq)
   */
  private String logisticsWarehouseLogisticsContainsEq;
  /**
   * 收货邮编包含 比较(neq)
   */
  private String logisticsWarehouseLogisticsContainsNeq;
  /**
   * 收货邮编包含 比较(gt)
   */
  private String logisticsWarehouseLogisticsContainsGt;
  /**
   * 收货邮编包含 比较(gte)
   */
  private String logisticsWarehouseLogisticsContainsGte;
  /**
   * 收货邮编包含 比较(lt)
   */
  private String logisticsWarehouseLogisticsContainsLt;
  /**
   * 收货邮编包含 比较(lte)
   */
  private String logisticsWarehouseLogisticsContainsLte;
  /**
   * 收货邮编包含 比较(contains)
   */
  private String logisticsWarehouseLogisticsContainsContains;
  /**
   * 收货邮编包含 比较(notcontains)
   */
  private String logisticsWarehouseLogisticsContainsNotcontains;
  /**
   * 收货邮编包含 比较(startswith)
   */
  private String logisticsWarehouseLogisticsContainsStartswith;
  /**
   * 收货邮编包含 比较(endswith)
   */
  private String logisticsWarehouseLogisticsContainsEndswith;
  /**
   * 收货邮编包含 比较(isnull)
   */
  private Boolean logisticsWarehouseLogisticsContainsIsnull;
  /**
   * 收货邮编包含 比较(isnotnull)
   */
  private Boolean logisticsWarehouseLogisticsContainsIsnotnull;

  /**
   * 收货邮编包含(精确搜索)
   */
  private List<String> logisticsWarehouseLogisticsContainsInList;

  /**
   * 两项满足其中一项
   */
  private String logisticsWarehouseLogisticsChooseOne;

  /**
   * 两项满足其中一项 比较(eq)
   */
  private String logisticsWarehouseLogisticsChooseOneEq;
  /**
   * 两项满足其中一项 比较(neq)
   */
  private String logisticsWarehouseLogisticsChooseOneNeq;
  /**
   * 两项满足其中一项 比较(gt)
   */
  private String logisticsWarehouseLogisticsChooseOneGt;
  /**
   * 两项满足其中一项 比较(gte)
   */
  private String logisticsWarehouseLogisticsChooseOneGte;
  /**
   * 两项满足其中一项 比较(lt)
   */
  private String logisticsWarehouseLogisticsChooseOneLt;
  /**
   * 两项满足其中一项 比较(lte)
   */
  private String logisticsWarehouseLogisticsChooseOneLte;
  /**
   * 两项满足其中一项 比较(contains)
   */
  private String logisticsWarehouseLogisticsChooseOneContains;
  /**
   * 两项满足其中一项 比较(notcontains)
   */
  private String logisticsWarehouseLogisticsChooseOneNotcontains;
  /**
   * 两项满足其中一项 比较(startswith)
   */
  private String logisticsWarehouseLogisticsChooseOneStartswith;
  /**
   * 两项满足其中一项 比较(endswith)
   */
  private String logisticsWarehouseLogisticsChooseOneEndswith;
  /**
   * 两项满足其中一项 比较(isnull)
   */
  private Boolean logisticsWarehouseLogisticsChooseOneIsnull;
  /**
   * 两项满足其中一项 比较(isnotnull)
   */
  private Boolean logisticsWarehouseLogisticsChooseOneIsnotnull;

  /**
   * 两项满足其中一项(精确搜索)
   */
  private List<String> logisticsWarehouseLogisticsChooseOneInList;

  /**
   * 指定收货邮编(模糊搜索)
   */
  private String logisticsWarehouseLogisticsWhite;

  /**
   * 指定收货邮编 比较(eq)
   */
  private String logisticsWarehouseLogisticsWhiteEq;
  /**
   * 指定收货邮编 比较(neq)
   */
  private String logisticsWarehouseLogisticsWhiteNeq;
  /**
   * 指定收货邮编 比较(gt)
   */
  private String logisticsWarehouseLogisticsWhiteGt;
  /**
   * 指定收货邮编 比较(gte)
   */
  private String logisticsWarehouseLogisticsWhiteGte;
  /**
   * 指定收货邮编 比较(lt)
   */
  private String logisticsWarehouseLogisticsWhiteLt;
  /**
   * 指定收货邮编 比较(lte)
   */
  private String logisticsWarehouseLogisticsWhiteLte;
  /**
   * 指定收货邮编 比较(contains)
   */
  private String logisticsWarehouseLogisticsWhiteContains;
  /**
   * 指定收货邮编 比较(notcontains)
   */
  private String logisticsWarehouseLogisticsWhiteNotcontains;
  /**
   * 指定收货邮编 比较(startswith)
   */
  private String logisticsWarehouseLogisticsWhiteStartswith;
  /**
   * 指定收货邮编 比较(endswith)
   */
  private String logisticsWarehouseLogisticsWhiteEndswith;
  /**
   * 指定收货邮编 比较(isnull)
   */
  private Boolean logisticsWarehouseLogisticsWhiteIsnull;
  /**
   * 指定收货邮编 比较(isnotnull)
   */
  private Boolean logisticsWarehouseLogisticsWhiteIsnotnull;

  /**
   * 指定收货邮编(精确搜索)
   */
  private List<String> logisticsWarehouseLogisticsWhiteInList;

  /**
   * 排除收货邮编(模糊搜索)
   */
  private String logisticsWarehouseLogisticsBlack;

  /**
   * 排除收货邮编 比较(eq)
   */
  private String logisticsWarehouseLogisticsBlackEq;
  /**
   * 排除收货邮编 比较(neq)
   */
  private String logisticsWarehouseLogisticsBlackNeq;
  /**
   * 排除收货邮编 比较(gt)
   */
  private String logisticsWarehouseLogisticsBlackGt;
  /**
   * 排除收货邮编 比较(gte)
   */
  private String logisticsWarehouseLogisticsBlackGte;
  /**
   * 排除收货邮编 比较(lt)
   */
  private String logisticsWarehouseLogisticsBlackLt;
  /**
   * 排除收货邮编 比较(lte)
   */
  private String logisticsWarehouseLogisticsBlackLte;
  /**
   * 排除收货邮编 比较(contains)
   */
  private String logisticsWarehouseLogisticsBlackContains;
  /**
   * 排除收货邮编 比较(notcontains)
   */
  private String logisticsWarehouseLogisticsBlackNotcontains;
  /**
   * 排除收货邮编 比较(startswith)
   */
  private String logisticsWarehouseLogisticsBlackStartswith;
  /**
   * 排除收货邮编 比较(endswith)
   */
  private String logisticsWarehouseLogisticsBlackEndswith;
  /**
   * 排除收货邮编 比较(isnull)
   */
  private Boolean logisticsWarehouseLogisticsBlackIsnull;
  /**
   * 排除收货邮编 比较(isnotnull)
   */
  private Boolean logisticsWarehouseLogisticsBlackIsnotnull;

  /**
   * 排除收货邮编(精确搜索)
   */
  private List<String> logisticsWarehouseLogisticsBlackInList;

  /**
   * 地址类型
   */
  private String logisticsWarehouseLogisticsAddressType;

  /**
   * 地址类型 比较(eq)
   */
  private String logisticsWarehouseLogisticsAddressTypeEq;
  /**
   * 地址类型 比较(neq)
   */
  private String logisticsWarehouseLogisticsAddressTypeNeq;
  /**
   * 地址类型 比较(gt)
   */
  private String logisticsWarehouseLogisticsAddressTypeGt;
  /**
   * 地址类型 比较(gte)
   */
  private String logisticsWarehouseLogisticsAddressTypeGte;
  /**
   * 地址类型 比较(lt)
   */
  private String logisticsWarehouseLogisticsAddressTypeLt;
  /**
   * 地址类型 比较(lte)
   */
  private String logisticsWarehouseLogisticsAddressTypeLte;
  /**
   * 地址类型 比较(contains)
   */
  private String logisticsWarehouseLogisticsAddressTypeContains;
  /**
   * 地址类型 比较(notcontains)
   */
  private String logisticsWarehouseLogisticsAddressTypeNotcontains;
  /**
   * 地址类型 比较(startswith)
   */
  private String logisticsWarehouseLogisticsAddressTypeStartswith;
  /**
   * 地址类型 比较(endswith)
   */
  private String logisticsWarehouseLogisticsAddressTypeEndswith;
  /**
   * 地址类型 比较(isnull)
   */
  private Boolean logisticsWarehouseLogisticsAddressTypeIsnull;
  /**
   * 地址类型 比较(isnotnull)
   */
  private Boolean logisticsWarehouseLogisticsAddressTypeIsnotnull;

  /**
   * 地址类型(精确搜索)
   */
  private List<String> logisticsWarehouseLogisticsAddressTypeInList;

  /**
   * 订单MSKU(模糊搜索)
   */
  private String logisticsOrderMsku;

  /**
   * 订单MSKU 比较(eq)
   */
  private String logisticsOrderMskuEq;
  /**
   * 订单MSKU 比较(neq)
   */
  private String logisticsOrderMskuNeq;
  /**
   * 订单MSKU 比较(gt)
   */
  private String logisticsOrderMskuGt;
  /**
   * 订单MSKU 比较(gte)
   */
  private String logisticsOrderMskuGte;
  /**
   * 订单MSKU 比较(lt)
   */
  private String logisticsOrderMskuLt;
  /**
   * 订单MSKU 比较(lte)
   */
  private String logisticsOrderMskuLte;
  /**
   * 订单MSKU 比较(contains)
   */
  private String logisticsOrderMskuContains;
  /**
   * 订单MSKU 比较(notcontains)
   */
  private String logisticsOrderMskuNotcontains;
  /**
   * 订单MSKU 比较(startswith)
   */
  private String logisticsOrderMskuStartswith;
  /**
   * 订单MSKU 比较(endswith)
   */
  private String logisticsOrderMskuEndswith;
  /**
   * 订单MSKU 比较(isnull)
   */
  private Boolean logisticsOrderMskuIsnull;
  /**
   * 订单MSKU 比较(isnotnull)
   */
  private Boolean logisticsOrderMskuIsnotnull;

  /**
   * 订单MSKU(精确搜索)
   */
  private List<String> logisticsOrderMskuInList;

  /**
   * 订单产品
   */
  private Long logisticsOrderProduct;

  /**
   * 订单产品 比较(eq)
   */
  private Long logisticsOrderProductEq;
  /**
   * 订单产品 比较(neq)
   */
  private Long logisticsOrderProductNeq;
  /**
   * 订单产品 比较(gt)
   */
  private Long logisticsOrderProductGt;
  /**
   * 订单产品 比较(gte)
   */
  private Long logisticsOrderProductGte;
  /**
   * 订单产品 比较(lt)
   */
  private Long logisticsOrderProductLt;
  /**
   * 订单产品 比较(lte)
   */
  private Long logisticsOrderProductLte;
  /**
   * 订单产品 比较(contains)
   */
  private Long logisticsOrderProductContains;
  /**
   * 订单产品 比较(notcontains)
   */
  private Long logisticsOrderProductNotcontains;
  /**
   * 订单产品 比较(startswith)
   */
  private Long logisticsOrderProductStartswith;
  /**
   * 订单产品 比较(endswith)
   */
  private Long logisticsOrderProductEndswith;
  /**
   * 订单产品 比较(isnull)
   */
  private Boolean logisticsOrderProductIsnull;
  /**
   * 订单产品 比较(isnotnull)
   */
  private Boolean logisticsOrderProductIsnotnull;
  /**
   * 订单产品的品名 比较(eq)
   */
  private String logisticsOrderProductNameEq;
  /**
   * 订单产品的品名 比较(neq)
   */
  private String logisticsOrderProductNameNeq;
  /**
   * 订单产品的品名 比较(gt)
   */
  private String logisticsOrderProductNameGt;
  /**
   * 订单产品的品名 比较(gte)
   */
  private String logisticsOrderProductNameGte;
  /**
   * 订单产品的品名 比较(lt)
   */
  private String logisticsOrderProductNameLt;
  /**
   * 订单产品的品名 比较(lte)
   */
  private String logisticsOrderProductNameLte;
  /**
   * 订单产品的品名 比较(contains)
   */
  private String logisticsOrderProductNameContains;
  /**
   * 订单产品的品名 比较(notcontains)
   */
  private String logisticsOrderProductNameNotcontains;
  /**
   * 订单产品的品名 比较(startswith)
   */
  private String logisticsOrderProductNameStartswith;
  /**
   * 订单产品的品名 比较(endswith)
   */
  private String logisticsOrderProductNameEndswith;
  /**
   * 订单产品的品名 比较(isnull)
   */
  private Boolean logisticsOrderProductNameIsnull;
  /**
   * 订单产品的品名 比较(isnotnull)
   */
  private Boolean logisticsOrderProductNameIsnotnull;

  /**
   * 产品分类
   */
  private Long logisticsOrderProductClassify;

  /**
   * 产品分类 比较(eq)
   */
  private Long logisticsOrderProductClassifyEq;
  /**
   * 产品分类 比较(neq)
   */
  private Long logisticsOrderProductClassifyNeq;
  /**
   * 产品分类 比较(gt)
   */
  private Long logisticsOrderProductClassifyGt;
  /**
   * 产品分类 比较(gte)
   */
  private Long logisticsOrderProductClassifyGte;
  /**
   * 产品分类 比较(lt)
   */
  private Long logisticsOrderProductClassifyLt;
  /**
   * 产品分类 比较(lte)
   */
  private Long logisticsOrderProductClassifyLte;
  /**
   * 产品分类 比较(contains)
   */
  private Long logisticsOrderProductClassifyContains;
  /**
   * 产品分类 比较(notcontains)
   */
  private Long logisticsOrderProductClassifyNotcontains;
  /**
   * 产品分类 比较(startswith)
   */
  private Long logisticsOrderProductClassifyStartswith;
  /**
   * 产品分类 比较(endswith)
   */
  private Long logisticsOrderProductClassifyEndswith;
  /**
   * 产品分类 比较(isnull)
   */
  private Boolean logisticsOrderProductClassifyIsnull;
  /**
   * 产品分类 比较(isnotnull)
   */
  private Boolean logisticsOrderProductClassifyIsnotnull;
  /**
   * 产品分类的分类名称 比较(eq)
   */
  private String logisticsOrderProductClassifyNameEq;
  /**
   * 产品分类的分类名称 比较(neq)
   */
  private String logisticsOrderProductClassifyNameNeq;
  /**
   * 产品分类的分类名称 比较(gt)
   */
  private String logisticsOrderProductClassifyNameGt;
  /**
   * 产品分类的分类名称 比较(gte)
   */
  private String logisticsOrderProductClassifyNameGte;
  /**
   * 产品分类的分类名称 比较(lt)
   */
  private String logisticsOrderProductClassifyNameLt;
  /**
   * 产品分类的分类名称 比较(lte)
   */
  private String logisticsOrderProductClassifyNameLte;
  /**
   * 产品分类的分类名称 比较(contains)
   */
  private String logisticsOrderProductClassifyNameContains;
  /**
   * 产品分类的分类名称 比较(notcontains)
   */
  private String logisticsOrderProductClassifyNameNotcontains;
  /**
   * 产品分类的分类名称 比较(startswith)
   */
  private String logisticsOrderProductClassifyNameStartswith;
  /**
   * 产品分类的分类名称 比较(endswith)
   */
  private String logisticsOrderProductClassifyNameEndswith;
  /**
   * 产品分类的分类名称 比较(isnull)
   */
  private Boolean logisticsOrderProductClassifyNameIsnull;
  /**
   * 产品分类的分类名称 比较(isnotnull)
   */
  private Boolean logisticsOrderProductClassifyNameIsnotnull;

  /**
   * 估算尺寸(模糊搜索)
   */
  private String logisticsOrderThinkSize;

  /**
   * 估算尺寸 比较(eq)
   */
  private String logisticsOrderThinkSizeEq;
  /**
   * 估算尺寸 比较(neq)
   */
  private String logisticsOrderThinkSizeNeq;
  /**
   * 估算尺寸 比较(gt)
   */
  private String logisticsOrderThinkSizeGt;
  /**
   * 估算尺寸 比较(gte)
   */
  private String logisticsOrderThinkSizeGte;
  /**
   * 估算尺寸 比较(lt)
   */
  private String logisticsOrderThinkSizeLt;
  /**
   * 估算尺寸 比较(lte)
   */
  private String logisticsOrderThinkSizeLte;
  /**
   * 估算尺寸 比较(contains)
   */
  private String logisticsOrderThinkSizeContains;
  /**
   * 估算尺寸 比较(notcontains)
   */
  private String logisticsOrderThinkSizeNotcontains;
  /**
   * 估算尺寸 比较(startswith)
   */
  private String logisticsOrderThinkSizeStartswith;
  /**
   * 估算尺寸 比较(endswith)
   */
  private String logisticsOrderThinkSizeEndswith;
  /**
   * 估算尺寸 比较(isnull)
   */
  private Boolean logisticsOrderThinkSizeIsnull;
  /**
   * 估算尺寸 比较(isnotnull)
   */
  private Boolean logisticsOrderThinkSizeIsnotnull;

  /**
   * 估算尺寸(精确搜索)
   */
  private List<String> logisticsOrderThinkSizeInList;

  /**
   * 估算重量(模糊搜索)
   */
  private String logisticsOrderThinkWeight;

  /**
   * 估算重量 比较(eq)
   */
  private String logisticsOrderThinkWeightEq;
  /**
   * 估算重量 比较(neq)
   */
  private String logisticsOrderThinkWeightNeq;
  /**
   * 估算重量 比较(gt)
   */
  private String logisticsOrderThinkWeightGt;
  /**
   * 估算重量 比较(gte)
   */
  private String logisticsOrderThinkWeightGte;
  /**
   * 估算重量 比较(lt)
   */
  private String logisticsOrderThinkWeightLt;
  /**
   * 估算重量 比较(lte)
   */
  private String logisticsOrderThinkWeightLte;
  /**
   * 估算重量 比较(contains)
   */
  private String logisticsOrderThinkWeightContains;
  /**
   * 估算重量 比较(notcontains)
   */
  private String logisticsOrderThinkWeightNotcontains;
  /**
   * 估算重量 比较(startswith)
   */
  private String logisticsOrderThinkWeightStartswith;
  /**
   * 估算重量 比较(endswith)
   */
  private String logisticsOrderThinkWeightEndswith;
  /**
   * 估算重量 比较(isnull)
   */
  private Boolean logisticsOrderThinkWeightIsnull;
  /**
   * 估算重量 比较(isnotnull)
   */
  private Boolean logisticsOrderThinkWeightIsnotnull;

  /**
   * 估算重量(精确搜索)
   */
  private List<String> logisticsOrderThinkWeightInList;

  /**
   * 订单总金额(模糊搜索)
   */
  private String logisticsOrderTotalAmount;

  /**
   * 订单总金额 比较(eq)
   */
  private String logisticsOrderTotalAmountEq;
  /**
   * 订单总金额 比较(neq)
   */
  private String logisticsOrderTotalAmountNeq;
  /**
   * 订单总金额 比较(gt)
   */
  private String logisticsOrderTotalAmountGt;
  /**
   * 订单总金额 比较(gte)
   */
  private String logisticsOrderTotalAmountGte;
  /**
   * 订单总金额 比较(lt)
   */
  private String logisticsOrderTotalAmountLt;
  /**
   * 订单总金额 比较(lte)
   */
  private String logisticsOrderTotalAmountLte;
  /**
   * 订单总金额 比较(contains)
   */
  private String logisticsOrderTotalAmountContains;
  /**
   * 订单总金额 比较(notcontains)
   */
  private String logisticsOrderTotalAmountNotcontains;
  /**
   * 订单总金额 比较(startswith)
   */
  private String logisticsOrderTotalAmountStartswith;
  /**
   * 订单总金额 比较(endswith)
   */
  private String logisticsOrderTotalAmountEndswith;
  /**
   * 订单总金额 比较(isnull)
   */
  private Boolean logisticsOrderTotalAmountIsnull;
  /**
   * 订单总金额 比较(isnotnull)
   */
  private Boolean logisticsOrderTotalAmountIsnotnull;

  /**
   * 订单总金额(精确搜索)
   */
  private List<String> logisticsOrderTotalAmountInList;

  /**
   * 客选物流
   */
  private Long logisticsOrderLogistics;

  /**
   * 客选物流 比较(eq)
   */
  private Long logisticsOrderLogisticsEq;
  /**
   * 客选物流 比较(neq)
   */
  private Long logisticsOrderLogisticsNeq;
  /**
   * 客选物流 比较(gt)
   */
  private Long logisticsOrderLogisticsGt;
  /**
   * 客选物流 比较(gte)
   */
  private Long logisticsOrderLogisticsGte;
  /**
   * 客选物流 比较(lt)
   */
  private Long logisticsOrderLogisticsLt;
  /**
   * 客选物流 比较(lte)
   */
  private Long logisticsOrderLogisticsLte;
  /**
   * 客选物流 比较(contains)
   */
  private Long logisticsOrderLogisticsContains;
  /**
   * 客选物流 比较(notcontains)
   */
  private Long logisticsOrderLogisticsNotcontains;
  /**
   * 客选物流 比较(startswith)
   */
  private Long logisticsOrderLogisticsStartswith;
  /**
   * 客选物流 比较(endswith)
   */
  private Long logisticsOrderLogisticsEndswith;
  /**
   * 客选物流 比较(isnull)
   */
  private Boolean logisticsOrderLogisticsIsnull;
  /**
   * 客选物流 比较(isnotnull)
   */
  private Boolean logisticsOrderLogisticsIsnotnull;
  /**
   * 客选物流的名称 比较(eq)
   */
  private String logisticsOrderLogisticsLabelEq;
  /**
   * 客选物流的名称 比较(neq)
   */
  private String logisticsOrderLogisticsLabelNeq;
  /**
   * 客选物流的名称 比较(gt)
   */
  private String logisticsOrderLogisticsLabelGt;
  /**
   * 客选物流的名称 比较(gte)
   */
  private String logisticsOrderLogisticsLabelGte;
  /**
   * 客选物流的名称 比较(lt)
   */
  private String logisticsOrderLogisticsLabelLt;
  /**
   * 客选物流的名称 比较(lte)
   */
  private String logisticsOrderLogisticsLabelLte;
  /**
   * 客选物流的名称 比较(contains)
   */
  private String logisticsOrderLogisticsLabelContains;
  /**
   * 客选物流的名称 比较(notcontains)
   */
  private String logisticsOrderLogisticsLabelNotcontains;
  /**
   * 客选物流的名称 比较(startswith)
   */
  private String logisticsOrderLogisticsLabelStartswith;
  /**
   * 客选物流的名称 比较(endswith)
   */
  private String logisticsOrderLogisticsLabelEndswith;
  /**
   * 客选物流的名称 比较(isnull)
   */
  private Boolean logisticsOrderLogisticsLabelIsnull;
  /**
   * 客选物流的名称 比较(isnotnull)
   */
  private Boolean logisticsOrderLogisticsLabelIsnotnull;

  /**
   * 客付运费(模糊搜索)
   */
  private String logisticsOrderFreight;

  /**
   * 客付运费 比较(eq)
   */
  private String logisticsOrderFreightEq;
  /**
   * 客付运费 比较(neq)
   */
  private String logisticsOrderFreightNeq;
  /**
   * 客付运费 比较(gt)
   */
  private String logisticsOrderFreightGt;
  /**
   * 客付运费 比较(gte)
   */
  private String logisticsOrderFreightGte;
  /**
   * 客付运费 比较(lt)
   */
  private String logisticsOrderFreightLt;
  /**
   * 客付运费 比较(lte)
   */
  private String logisticsOrderFreightLte;
  /**
   * 客付运费 比较(contains)
   */
  private String logisticsOrderFreightContains;
  /**
   * 客付运费 比较(notcontains)
   */
  private String logisticsOrderFreightNotcontains;
  /**
   * 客付运费 比较(startswith)
   */
  private String logisticsOrderFreightStartswith;
  /**
   * 客付运费 比较(endswith)
   */
  private String logisticsOrderFreightEndswith;
  /**
   * 客付运费 比较(isnull)
   */
  private Boolean logisticsOrderFreightIsnull;
  /**
   * 客付运费 比较(isnotnull)
   */
  private Boolean logisticsOrderFreightIsnotnull;

  /**
   * 客付运费(精确搜索)
   */
  private List<String> logisticsOrderFreightInList;

  /**
   * 特殊属性
   */
  private String logisticsOrderSpecial;

  /**
   * 特殊属性 比较(eq)
   */
  private String logisticsOrderSpecialEq;
  /**
   * 特殊属性 比较(neq)
   */
  private String logisticsOrderSpecialNeq;
  /**
   * 特殊属性 比较(gt)
   */
  private String logisticsOrderSpecialGt;
  /**
   * 特殊属性 比较(gte)
   */
  private String logisticsOrderSpecialGte;
  /**
   * 特殊属性 比较(lt)
   */
  private String logisticsOrderSpecialLt;
  /**
   * 特殊属性 比较(lte)
   */
  private String logisticsOrderSpecialLte;
  /**
   * 特殊属性 比较(contains)
   */
  private String logisticsOrderSpecialContains;
  /**
   * 特殊属性 比较(notcontains)
   */
  private String logisticsOrderSpecialNotcontains;
  /**
   * 特殊属性 比较(startswith)
   */
  private String logisticsOrderSpecialStartswith;
  /**
   * 特殊属性 比较(endswith)
   */
  private String logisticsOrderSpecialEndswith;
  /**
   * 特殊属性 比较(isnull)
   */
  private Boolean logisticsOrderSpecialIsnull;
  /**
   * 特殊属性 比较(isnotnull)
   */
  private Boolean logisticsOrderSpecialIsnotnull;

  /**
   * 特殊属性(精确搜索)
   */
  private List<String> logisticsOrderSpecialInList;

  /**
   * 毛利润率(模糊搜索)
   */
  private String logisticsOrderGrossMargin;

  /**
   * 毛利润率 比较(eq)
   */
  private String logisticsOrderGrossMarginEq;
  /**
   * 毛利润率 比较(neq)
   */
  private String logisticsOrderGrossMarginNeq;
  /**
   * 毛利润率 比较(gt)
   */
  private String logisticsOrderGrossMarginGt;
  /**
   * 毛利润率 比较(gte)
   */
  private String logisticsOrderGrossMarginGte;
  /**
   * 毛利润率 比较(lt)
   */
  private String logisticsOrderGrossMarginLt;
  /**
   * 毛利润率 比较(lte)
   */
  private String logisticsOrderGrossMarginLte;
  /**
   * 毛利润率 比较(contains)
   */
  private String logisticsOrderGrossMarginContains;
  /**
   * 毛利润率 比较(notcontains)
   */
  private String logisticsOrderGrossMarginNotcontains;
  /**
   * 毛利润率 比较(startswith)
   */
  private String logisticsOrderGrossMarginStartswith;
  /**
   * 毛利润率 比较(endswith)
   */
  private String logisticsOrderGrossMarginEndswith;
  /**
   * 毛利润率 比较(isnull)
   */
  private Boolean logisticsOrderGrossMarginIsnull;
  /**
   * 毛利润率 比较(isnotnull)
   */
  private Boolean logisticsOrderGrossMarginIsnotnull;

  /**
   * 毛利润率(精确搜索)
   */
  private List<String> logisticsOrderGrossMarginInList;

  /**
   * 设定方式
   */
  private String logisticsActSettingMethod;

  /**
   * 设定方式 比较(eq)
   */
  private String logisticsActSettingMethodEq;
  /**
   * 设定方式 比较(neq)
   */
  private String logisticsActSettingMethodNeq;
  /**
   * 设定方式 比较(gt)
   */
  private String logisticsActSettingMethodGt;
  /**
   * 设定方式 比较(gte)
   */
  private String logisticsActSettingMethodGte;
  /**
   * 设定方式 比较(lt)
   */
  private String logisticsActSettingMethodLt;
  /**
   * 设定方式 比较(lte)
   */
  private String logisticsActSettingMethodLte;
  /**
   * 设定方式 比较(contains)
   */
  private String logisticsActSettingMethodContains;
  /**
   * 设定方式 比较(notcontains)
   */
  private String logisticsActSettingMethodNotcontains;
  /**
   * 设定方式 比较(startswith)
   */
  private String logisticsActSettingMethodStartswith;
  /**
   * 设定方式 比较(endswith)
   */
  private String logisticsActSettingMethodEndswith;
  /**
   * 设定方式 比较(isnull)
   */
  private Boolean logisticsActSettingMethodIsnull;
  /**
   * 设定方式 比较(isnotnull)
   */
  private Boolean logisticsActSettingMethodIsnotnull;

  /**
   * 设定方式(精确搜索)
   */
  private List<String> logisticsActSettingMethodInList;

  /**
   * 物流方式
   */
  private Long logisticsActChannel;

  /**
   * 物流方式 比较(eq)
   */
  private Long logisticsActChannelEq;
  /**
   * 物流方式 比较(neq)
   */
  private Long logisticsActChannelNeq;
  /**
   * 物流方式 比较(gt)
   */
  private Long logisticsActChannelGt;
  /**
   * 物流方式 比较(gte)
   */
  private Long logisticsActChannelGte;
  /**
   * 物流方式 比较(lt)
   */
  private Long logisticsActChannelLt;
  /**
   * 物流方式 比较(lte)
   */
  private Long logisticsActChannelLte;
  /**
   * 物流方式 比较(contains)
   */
  private Long logisticsActChannelContains;
  /**
   * 物流方式 比较(notcontains)
   */
  private Long logisticsActChannelNotcontains;
  /**
   * 物流方式 比较(startswith)
   */
  private Long logisticsActChannelStartswith;
  /**
   * 物流方式 比较(endswith)
   */
  private Long logisticsActChannelEndswith;
  /**
   * 物流方式 比较(isnull)
   */
  private Boolean logisticsActChannelIsnull;
  /**
   * 物流方式 比较(isnotnull)
   */
  private Boolean logisticsActChannelIsnotnull;
  /**
   * 物流方式的名称 比较(eq)
   */
  private String logisticsActChannelLabelEq;
  /**
   * 物流方式的名称 比较(neq)
   */
  private String logisticsActChannelLabelNeq;
  /**
   * 物流方式的名称 比较(gt)
   */
  private String logisticsActChannelLabelGt;
  /**
   * 物流方式的名称 比较(gte)
   */
  private String logisticsActChannelLabelGte;
  /**
   * 物流方式的名称 比较(lt)
   */
  private String logisticsActChannelLabelLt;
  /**
   * 物流方式的名称 比较(lte)
   */
  private String logisticsActChannelLabelLte;
  /**
   * 物流方式的名称 比较(contains)
   */
  private String logisticsActChannelLabelContains;
  /**
   * 物流方式的名称 比较(notcontains)
   */
  private String logisticsActChannelLabelNotcontains;
  /**
   * 物流方式的名称 比较(startswith)
   */
  private String logisticsActChannelLabelStartswith;
  /**
   * 物流方式的名称 比较(endswith)
   */
  private String logisticsActChannelLabelEndswith;
  /**
   * 物流方式的名称 比较(isnull)
   */
  private Boolean logisticsActChannelLabelIsnull;
  /**
   * 物流方式的名称 比较(isnotnull)
   */
  private Boolean logisticsActChannelLabelIsnotnull;

  /**
   * 海外仓物流自动设定对应海外仓
   */
  private String logisticsActOverseasWarehouseAutoMapping;

  /**
   * 海外仓物流自动设定对应海外仓 比较(eq)
   */
  private String logisticsActOverseasWarehouseAutoMappingEq;
  /**
   * 海外仓物流自动设定对应海外仓 比较(neq)
   */
  private String logisticsActOverseasWarehouseAutoMappingNeq;
  /**
   * 海外仓物流自动设定对应海外仓 比较(gt)
   */
  private String logisticsActOverseasWarehouseAutoMappingGt;
  /**
   * 海外仓物流自动设定对应海外仓 比较(gte)
   */
  private String logisticsActOverseasWarehouseAutoMappingGte;
  /**
   * 海外仓物流自动设定对应海外仓 比较(lt)
   */
  private String logisticsActOverseasWarehouseAutoMappingLt;
  /**
   * 海外仓物流自动设定对应海外仓 比较(lte)
   */
  private String logisticsActOverseasWarehouseAutoMappingLte;
  /**
   * 海外仓物流自动设定对应海外仓 比较(contains)
   */
  private String logisticsActOverseasWarehouseAutoMappingContains;
  /**
   * 海外仓物流自动设定对应海外仓 比较(notcontains)
   */
  private String logisticsActOverseasWarehouseAutoMappingNotcontains;
  /**
   * 海外仓物流自动设定对应海外仓 比较(startswith)
   */
  private String logisticsActOverseasWarehouseAutoMappingStartswith;
  /**
   * 海外仓物流自动设定对应海外仓 比较(endswith)
   */
  private String logisticsActOverseasWarehouseAutoMappingEndswith;
  /**
   * 海外仓物流自动设定对应海外仓 比较(isnull)
   */
  private Boolean logisticsActOverseasWarehouseAutoMappingIsnull;
  /**
   * 海外仓物流自动设定对应海外仓 比较(isnotnull)
   */
  private Boolean logisticsActOverseasWarehouseAutoMappingIsnotnull;

  /**
   * 海外仓物流自动设定对应海外仓(精确搜索)
   */
  private List<String> logisticsActOverseasWarehouseAutoMappingInList;

  /**
   * 自动覆盖订单原有物流
   */
  private String logisticsActAutoCoverOriginal;

  /**
   * 自动覆盖订单原有物流 比较(eq)
   */
  private String logisticsActAutoCoverOriginalEq;
  /**
   * 自动覆盖订单原有物流 比较(neq)
   */
  private String logisticsActAutoCoverOriginalNeq;
  /**
   * 自动覆盖订单原有物流 比较(gt)
   */
  private String logisticsActAutoCoverOriginalGt;
  /**
   * 自动覆盖订单原有物流 比较(gte)
   */
  private String logisticsActAutoCoverOriginalGte;
  /**
   * 自动覆盖订单原有物流 比较(lt)
   */
  private String logisticsActAutoCoverOriginalLt;
  /**
   * 自动覆盖订单原有物流 比较(lte)
   */
  private String logisticsActAutoCoverOriginalLte;
  /**
   * 自动覆盖订单原有物流 比较(contains)
   */
  private String logisticsActAutoCoverOriginalContains;
  /**
   * 自动覆盖订单原有物流 比较(notcontains)
   */
  private String logisticsActAutoCoverOriginalNotcontains;
  /**
   * 自动覆盖订单原有物流 比较(startswith)
   */
  private String logisticsActAutoCoverOriginalStartswith;
  /**
   * 自动覆盖订单原有物流 比较(endswith)
   */
  private String logisticsActAutoCoverOriginalEndswith;
  /**
   * 自动覆盖订单原有物流 比较(isnull)
   */
  private Boolean logisticsActAutoCoverOriginalIsnull;
  /**
   * 自动覆盖订单原有物流 比较(isnotnull)
   */
  private Boolean logisticsActAutoCoverOriginalIsnotnull;

  /**
   * 自动覆盖订单原有物流(精确搜索)
   */
  private List<String> logisticsActAutoCoverOriginalInList;

  /**
   * 比价方式
   */
  private String logisticsActPriceParity;

  /**
   * 比价方式 比较(eq)
   */
  private String logisticsActPriceParityEq;
  /**
   * 比价方式 比较(neq)
   */
  private String logisticsActPriceParityNeq;
  /**
   * 比价方式 比较(gt)
   */
  private String logisticsActPriceParityGt;
  /**
   * 比价方式 比较(gte)
   */
  private String logisticsActPriceParityGte;
  /**
   * 比价方式 比较(lt)
   */
  private String logisticsActPriceParityLt;
  /**
   * 比价方式 比较(lte)
   */
  private String logisticsActPriceParityLte;
  /**
   * 比价方式 比较(contains)
   */
  private String logisticsActPriceParityContains;
  /**
   * 比价方式 比较(notcontains)
   */
  private String logisticsActPriceParityNotcontains;
  /**
   * 比价方式 比较(startswith)
   */
  private String logisticsActPriceParityStartswith;
  /**
   * 比价方式 比较(endswith)
   */
  private String logisticsActPriceParityEndswith;
  /**
   * 比价方式 比较(isnull)
   */
  private Boolean logisticsActPriceParityIsnull;
  /**
   * 比价方式 比较(isnotnull)
   */
  private Boolean logisticsActPriceParityIsnotnull;

  /**
   * 比价方式(精确搜索)
   */
  private List<String> logisticsActPriceParityInList;

  /**
   * 指定物流
   */
  private Long logisticsActProvider;

  /**
   * 指定物流 比较(eq)
   */
  private Long logisticsActProviderEq;
  /**
   * 指定物流 比较(neq)
   */
  private Long logisticsActProviderNeq;
  /**
   * 指定物流 比较(gt)
   */
  private Long logisticsActProviderGt;
  /**
   * 指定物流 比较(gte)
   */
  private Long logisticsActProviderGte;
  /**
   * 指定物流 比较(lt)
   */
  private Long logisticsActProviderLt;
  /**
   * 指定物流 比较(lte)
   */
  private Long logisticsActProviderLte;
  /**
   * 指定物流 比较(contains)
   */
  private Long logisticsActProviderContains;
  /**
   * 指定物流 比较(notcontains)
   */
  private Long logisticsActProviderNotcontains;
  /**
   * 指定物流 比较(startswith)
   */
  private Long logisticsActProviderStartswith;
  /**
   * 指定物流 比较(endswith)
   */
  private Long logisticsActProviderEndswith;
  /**
   * 指定物流 比较(isnull)
   */
  private Boolean logisticsActProviderIsnull;
  /**
   * 指定物流 比较(isnotnull)
   */
  private Boolean logisticsActProviderIsnotnull;
  /**
   * 指定物流的名称 比较(eq)
   */
  private String logisticsActProviderLabelEq;
  /**
   * 指定物流的名称 比较(neq)
   */
  private String logisticsActProviderLabelNeq;
  /**
   * 指定物流的名称 比较(gt)
   */
  private String logisticsActProviderLabelGt;
  /**
   * 指定物流的名称 比较(gte)
   */
  private String logisticsActProviderLabelGte;
  /**
   * 指定物流的名称 比较(lt)
   */
  private String logisticsActProviderLabelLt;
  /**
   * 指定物流的名称 比较(lte)
   */
  private String logisticsActProviderLabelLte;
  /**
   * 指定物流的名称 比较(contains)
   */
  private String logisticsActProviderLabelContains;
  /**
   * 指定物流的名称 比较(notcontains)
   */
  private String logisticsActProviderLabelNotcontains;
  /**
   * 指定物流的名称 比较(startswith)
   */
  private String logisticsActProviderLabelStartswith;
  /**
   * 指定物流的名称 比较(endswith)
   */
  private String logisticsActProviderLabelEndswith;
  /**
   * 指定物流的名称 比较(isnull)
   */
  private Boolean logisticsActProviderLabelIsnull;
  /**
   * 指定物流的名称 比较(isnotnull)
   */
  private Boolean logisticsActProviderLabelIsnotnull;

  /**
   * 订单来源
   */
  private String addressBaseSource;

  /**
   * 订单来源 比较(eq)
   */
  private String addressBaseSourceEq;
  /**
   * 订单来源 比较(neq)
   */
  private String addressBaseSourceNeq;
  /**
   * 订单来源 比较(gt)
   */
  private String addressBaseSourceGt;
  /**
   * 订单来源 比较(gte)
   */
  private String addressBaseSourceGte;
  /**
   * 订单来源 比较(lt)
   */
  private String addressBaseSourceLt;
  /**
   * 订单来源 比较(lte)
   */
  private String addressBaseSourceLte;
  /**
   * 订单来源 比较(contains)
   */
  private String addressBaseSourceContains;
  /**
   * 订单来源 比较(notcontains)
   */
  private String addressBaseSourceNotcontains;
  /**
   * 订单来源 比较(startswith)
   */
  private String addressBaseSourceStartswith;
  /**
   * 订单来源 比较(endswith)
   */
  private String addressBaseSourceEndswith;
  /**
   * 订单来源 比较(isnull)
   */
  private Boolean addressBaseSourceIsnull;
  /**
   * 订单来源 比较(isnotnull)
   */
  private Boolean addressBaseSourceIsnotnull;

  /**
   * 订单来源(精确搜索)
   */
  private List<String> addressBaseSourceInList;

  /**
   * 订单平台
   */
  private String addressBaseOrderPlatform;

  /**
   * 订单平台 比较(eq)
   */
  private String addressBaseOrderPlatformEq;
  /**
   * 订单平台 比较(neq)
   */
  private String addressBaseOrderPlatformNeq;
  /**
   * 订单平台 比较(gt)
   */
  private String addressBaseOrderPlatformGt;
  /**
   * 订单平台 比较(gte)
   */
  private String addressBaseOrderPlatformGte;
  /**
   * 订单平台 比较(lt)
   */
  private String addressBaseOrderPlatformLt;
  /**
   * 订单平台 比较(lte)
   */
  private String addressBaseOrderPlatformLte;
  /**
   * 订单平台 比较(contains)
   */
  private String addressBaseOrderPlatformContains;
  /**
   * 订单平台 比较(notcontains)
   */
  private String addressBaseOrderPlatformNotcontains;
  /**
   * 订单平台 比较(startswith)
   */
  private String addressBaseOrderPlatformStartswith;
  /**
   * 订单平台 比较(endswith)
   */
  private String addressBaseOrderPlatformEndswith;
  /**
   * 订单平台 比较(isnull)
   */
  private Boolean addressBaseOrderPlatformIsnull;
  /**
   * 订单平台 比较(isnotnull)
   */
  private Boolean addressBaseOrderPlatformIsnotnull;

  /**
   * 订单平台(精确搜索)
   */
  private List<String> addressBaseOrderPlatformInList;

  /**
   * 订单站点
   */
  private Long addressBaseOrderSite;

  /**
   * 订单站点 比较(eq)
   */
  private Long addressBaseOrderSiteEq;
  /**
   * 订单站点 比较(neq)
   */
  private Long addressBaseOrderSiteNeq;
  /**
   * 订单站点 比较(gt)
   */
  private Long addressBaseOrderSiteGt;
  /**
   * 订单站点 比较(gte)
   */
  private Long addressBaseOrderSiteGte;
  /**
   * 订单站点 比较(lt)
   */
  private Long addressBaseOrderSiteLt;
  /**
   * 订单站点 比较(lte)
   */
  private Long addressBaseOrderSiteLte;
  /**
   * 订单站点 比较(contains)
   */
  private Long addressBaseOrderSiteContains;
  /**
   * 订单站点 比较(notcontains)
   */
  private Long addressBaseOrderSiteNotcontains;
  /**
   * 订单站点 比较(startswith)
   */
  private Long addressBaseOrderSiteStartswith;
  /**
   * 订单站点 比较(endswith)
   */
  private Long addressBaseOrderSiteEndswith;
  /**
   * 订单站点 比较(isnull)
   */
  private Boolean addressBaseOrderSiteIsnull;
  /**
   * 订单站点 比较(isnotnull)
   */
  private Boolean addressBaseOrderSiteIsnotnull;
  /**
   * 订单站点的名称 比较(eq)
   */
  private String addressBaseOrderSiteNameEq;
  /**
   * 订单站点的名称 比较(neq)
   */
  private String addressBaseOrderSiteNameNeq;
  /**
   * 订单站点的名称 比较(gt)
   */
  private String addressBaseOrderSiteNameGt;
  /**
   * 订单站点的名称 比较(gte)
   */
  private String addressBaseOrderSiteNameGte;
  /**
   * 订单站点的名称 比较(lt)
   */
  private String addressBaseOrderSiteNameLt;
  /**
   * 订单站点的名称 比较(lte)
   */
  private String addressBaseOrderSiteNameLte;
  /**
   * 订单站点的名称 比较(contains)
   */
  private String addressBaseOrderSiteNameContains;
  /**
   * 订单站点的名称 比较(notcontains)
   */
  private String addressBaseOrderSiteNameNotcontains;
  /**
   * 订单站点的名称 比较(startswith)
   */
  private String addressBaseOrderSiteNameStartswith;
  /**
   * 订单站点的名称 比较(endswith)
   */
  private String addressBaseOrderSiteNameEndswith;
  /**
   * 订单站点的名称 比较(isnull)
   */
  private Boolean addressBaseOrderSiteNameIsnull;
  /**
   * 订单站点的名称 比较(isnotnull)
   */
  private Boolean addressBaseOrderSiteNameIsnotnull;

  /**
   * 订单店铺
   */
  private Long addressBaseOrderShopInfo;

  /**
   * 订单店铺 比较(eq)
   */
  private Long addressBaseOrderShopInfoEq;
  /**
   * 订单店铺 比较(neq)
   */
  private Long addressBaseOrderShopInfoNeq;
  /**
   * 订单店铺 比较(gt)
   */
  private Long addressBaseOrderShopInfoGt;
  /**
   * 订单店铺 比较(gte)
   */
  private Long addressBaseOrderShopInfoGte;
  /**
   * 订单店铺 比较(lt)
   */
  private Long addressBaseOrderShopInfoLt;
  /**
   * 订单店铺 比较(lte)
   */
  private Long addressBaseOrderShopInfoLte;
  /**
   * 订单店铺 比较(contains)
   */
  private Long addressBaseOrderShopInfoContains;
  /**
   * 订单店铺 比较(notcontains)
   */
  private Long addressBaseOrderShopInfoNotcontains;
  /**
   * 订单店铺 比较(startswith)
   */
  private Long addressBaseOrderShopInfoStartswith;
  /**
   * 订单店铺 比较(endswith)
   */
  private Long addressBaseOrderShopInfoEndswith;
  /**
   * 订单店铺 比较(isnull)
   */
  private Boolean addressBaseOrderShopInfoIsnull;
  /**
   * 订单店铺 比较(isnotnull)
   */
  private Boolean addressBaseOrderShopInfoIsnotnull;
  /**
   * 订单店铺的名称 比较(eq)
   */
  private String addressBaseOrderShopInfoShopNameEq;
  /**
   * 订单店铺的名称 比较(neq)
   */
  private String addressBaseOrderShopInfoShopNameNeq;
  /**
   * 订单店铺的名称 比较(gt)
   */
  private String addressBaseOrderShopInfoShopNameGt;
  /**
   * 订单店铺的名称 比较(gte)
   */
  private String addressBaseOrderShopInfoShopNameGte;
  /**
   * 订单店铺的名称 比较(lt)
   */
  private String addressBaseOrderShopInfoShopNameLt;
  /**
   * 订单店铺的名称 比较(lte)
   */
  private String addressBaseOrderShopInfoShopNameLte;
  /**
   * 订单店铺的名称 比较(contains)
   */
  private String addressBaseOrderShopInfoShopNameContains;
  /**
   * 订单店铺的名称 比较(notcontains)
   */
  private String addressBaseOrderShopInfoShopNameNotcontains;
  /**
   * 订单店铺的名称 比较(startswith)
   */
  private String addressBaseOrderShopInfoShopNameStartswith;
  /**
   * 订单店铺的名称 比较(endswith)
   */
  private String addressBaseOrderShopInfoShopNameEndswith;
  /**
   * 订单店铺的名称 比较(isnull)
   */
  private Boolean addressBaseOrderShopInfoShopNameIsnull;
  /**
   * 订单店铺的名称 比较(isnotnull)
   */
  private Boolean addressBaseOrderShopInfoShopNameIsnotnull;

  /**
   * 发货仓库
   */
  private Long addressWarehouseLogisticsDeliveryWarehouse;

  /**
   * 发货仓库 比较(eq)
   */
  private Long addressWarehouseLogisticsDeliveryWarehouseEq;
  /**
   * 发货仓库 比较(neq)
   */
  private Long addressWarehouseLogisticsDeliveryWarehouseNeq;
  /**
   * 发货仓库 比较(gt)
   */
  private Long addressWarehouseLogisticsDeliveryWarehouseGt;
  /**
   * 发货仓库 比较(gte)
   */
  private Long addressWarehouseLogisticsDeliveryWarehouseGte;
  /**
   * 发货仓库 比较(lt)
   */
  private Long addressWarehouseLogisticsDeliveryWarehouseLt;
  /**
   * 发货仓库 比较(lte)
   */
  private Long addressWarehouseLogisticsDeliveryWarehouseLte;
  /**
   * 发货仓库 比较(contains)
   */
  private Long addressWarehouseLogisticsDeliveryWarehouseContains;
  /**
   * 发货仓库 比较(notcontains)
   */
  private Long addressWarehouseLogisticsDeliveryWarehouseNotcontains;
  /**
   * 发货仓库 比较(startswith)
   */
  private Long addressWarehouseLogisticsDeliveryWarehouseStartswith;
  /**
   * 发货仓库 比较(endswith)
   */
  private Long addressWarehouseLogisticsDeliveryWarehouseEndswith;
  /**
   * 发货仓库 比较(isnull)
   */
  private Boolean addressWarehouseLogisticsDeliveryWarehouseIsnull;
  /**
   * 发货仓库 比较(isnotnull)
   */
  private Boolean addressWarehouseLogisticsDeliveryWarehouseIsnotnull;
  /**
   * 发货仓库的仓库名称 比较(eq)
   */
  private String addressWarehouseLogisticsDeliveryWarehouseNameEq;
  /**
   * 发货仓库的仓库名称 比较(neq)
   */
  private String addressWarehouseLogisticsDeliveryWarehouseNameNeq;
  /**
   * 发货仓库的仓库名称 比较(gt)
   */
  private String addressWarehouseLogisticsDeliveryWarehouseNameGt;
  /**
   * 发货仓库的仓库名称 比较(gte)
   */
  private String addressWarehouseLogisticsDeliveryWarehouseNameGte;
  /**
   * 发货仓库的仓库名称 比较(lt)
   */
  private String addressWarehouseLogisticsDeliveryWarehouseNameLt;
  /**
   * 发货仓库的仓库名称 比较(lte)
   */
  private String addressWarehouseLogisticsDeliveryWarehouseNameLte;
  /**
   * 发货仓库的仓库名称 比较(contains)
   */
  private String addressWarehouseLogisticsDeliveryWarehouseNameContains;
  /**
   * 发货仓库的仓库名称 比较(notcontains)
   */
  private String addressWarehouseLogisticsDeliveryWarehouseNameNotcontains;
  /**
   * 发货仓库的仓库名称 比较(startswith)
   */
  private String addressWarehouseLogisticsDeliveryWarehouseNameStartswith;
  /**
   * 发货仓库的仓库名称 比较(endswith)
   */
  private String addressWarehouseLogisticsDeliveryWarehouseNameEndswith;
  /**
   * 发货仓库的仓库名称 比较(isnull)
   */
  private Boolean addressWarehouseLogisticsDeliveryWarehouseNameIsnull;
  /**
   * 发货仓库的仓库名称 比较(isnotnull)
   */
  private Boolean addressWarehouseLogisticsDeliveryWarehouseNameIsnotnull;

  /**
   * 物流商
   */
  private Long addressWarehouseLogisticsProvider;

  /**
   * 物流商 比较(eq)
   */
  private Long addressWarehouseLogisticsProviderEq;
  /**
   * 物流商 比较(neq)
   */
  private Long addressWarehouseLogisticsProviderNeq;
  /**
   * 物流商 比较(gt)
   */
  private Long addressWarehouseLogisticsProviderGt;
  /**
   * 物流商 比较(gte)
   */
  private Long addressWarehouseLogisticsProviderGte;
  /**
   * 物流商 比较(lt)
   */
  private Long addressWarehouseLogisticsProviderLt;
  /**
   * 物流商 比较(lte)
   */
  private Long addressWarehouseLogisticsProviderLte;
  /**
   * 物流商 比较(contains)
   */
  private Long addressWarehouseLogisticsProviderContains;
  /**
   * 物流商 比较(notcontains)
   */
  private Long addressWarehouseLogisticsProviderNotcontains;
  /**
   * 物流商 比较(startswith)
   */
  private Long addressWarehouseLogisticsProviderStartswith;
  /**
   * 物流商 比较(endswith)
   */
  private Long addressWarehouseLogisticsProviderEndswith;
  /**
   * 物流商 比较(isnull)
   */
  private Boolean addressWarehouseLogisticsProviderIsnull;
  /**
   * 物流商 比较(isnotnull)
   */
  private Boolean addressWarehouseLogisticsProviderIsnotnull;
  /**
   * 物流商的名称 比较(eq)
   */
  private String addressWarehouseLogisticsProviderLabelEq;
  /**
   * 物流商的名称 比较(neq)
   */
  private String addressWarehouseLogisticsProviderLabelNeq;
  /**
   * 物流商的名称 比较(gt)
   */
  private String addressWarehouseLogisticsProviderLabelGt;
  /**
   * 物流商的名称 比较(gte)
   */
  private String addressWarehouseLogisticsProviderLabelGte;
  /**
   * 物流商的名称 比较(lt)
   */
  private String addressWarehouseLogisticsProviderLabelLt;
  /**
   * 物流商的名称 比较(lte)
   */
  private String addressWarehouseLogisticsProviderLabelLte;
  /**
   * 物流商的名称 比较(contains)
   */
  private String addressWarehouseLogisticsProviderLabelContains;
  /**
   * 物流商的名称 比较(notcontains)
   */
  private String addressWarehouseLogisticsProviderLabelNotcontains;
  /**
   * 物流商的名称 比较(startswith)
   */
  private String addressWarehouseLogisticsProviderLabelStartswith;
  /**
   * 物流商的名称 比较(endswith)
   */
  private String addressWarehouseLogisticsProviderLabelEndswith;
  /**
   * 物流商的名称 比较(isnull)
   */
  private Boolean addressWarehouseLogisticsProviderLabelIsnull;
  /**
   * 物流商的名称 比较(isnotnull)
   */
  private Boolean addressWarehouseLogisticsProviderLabelIsnotnull;

  /**
   * 物流方式
   */
  private Long addressWarehouseLogisticsChannel;

  /**
   * 物流方式 比较(eq)
   */
  private Long addressWarehouseLogisticsChannelEq;
  /**
   * 物流方式 比较(neq)
   */
  private Long addressWarehouseLogisticsChannelNeq;
  /**
   * 物流方式 比较(gt)
   */
  private Long addressWarehouseLogisticsChannelGt;
  /**
   * 物流方式 比较(gte)
   */
  private Long addressWarehouseLogisticsChannelGte;
  /**
   * 物流方式 比较(lt)
   */
  private Long addressWarehouseLogisticsChannelLt;
  /**
   * 物流方式 比较(lte)
   */
  private Long addressWarehouseLogisticsChannelLte;
  /**
   * 物流方式 比较(contains)
   */
  private Long addressWarehouseLogisticsChannelContains;
  /**
   * 物流方式 比较(notcontains)
   */
  private Long addressWarehouseLogisticsChannelNotcontains;
  /**
   * 物流方式 比较(startswith)
   */
  private Long addressWarehouseLogisticsChannelStartswith;
  /**
   * 物流方式 比较(endswith)
   */
  private Long addressWarehouseLogisticsChannelEndswith;
  /**
   * 物流方式 比较(isnull)
   */
  private Boolean addressWarehouseLogisticsChannelIsnull;
  /**
   * 物流方式 比较(isnotnull)
   */
  private Boolean addressWarehouseLogisticsChannelIsnotnull;
  /**
   * 物流方式的名称 比较(eq)
   */
  private String addressWarehouseLogisticsChannelLabelEq;
  /**
   * 物流方式的名称 比较(neq)
   */
  private String addressWarehouseLogisticsChannelLabelNeq;
  /**
   * 物流方式的名称 比较(gt)
   */
  private String addressWarehouseLogisticsChannelLabelGt;
  /**
   * 物流方式的名称 比较(gte)
   */
  private String addressWarehouseLogisticsChannelLabelGte;
  /**
   * 物流方式的名称 比较(lt)
   */
  private String addressWarehouseLogisticsChannelLabelLt;
  /**
   * 物流方式的名称 比较(lte)
   */
  private String addressWarehouseLogisticsChannelLabelLte;
  /**
   * 物流方式的名称 比较(contains)
   */
  private String addressWarehouseLogisticsChannelLabelContains;
  /**
   * 物流方式的名称 比较(notcontains)
   */
  private String addressWarehouseLogisticsChannelLabelNotcontains;
  /**
   * 物流方式的名称 比较(startswith)
   */
  private String addressWarehouseLogisticsChannelLabelStartswith;
  /**
   * 物流方式的名称 比较(endswith)
   */
  private String addressWarehouseLogisticsChannelLabelEndswith;
  /**
   * 物流方式的名称 比较(isnull)
   */
  private Boolean addressWarehouseLogisticsChannelLabelIsnull;
  /**
   * 物流方式的名称 比较(isnotnull)
   */
  private Boolean addressWarehouseLogisticsChannelLabelIsnotnull;

  /**
   * 收货国家/地区
   */
  private Long addressWarehouseLogisticsCountry;

  /**
   * 收货国家/地区 比较(eq)
   */
  private Long addressWarehouseLogisticsCountryEq;
  /**
   * 收货国家/地区 比较(neq)
   */
  private Long addressWarehouseLogisticsCountryNeq;
  /**
   * 收货国家/地区 比较(gt)
   */
  private Long addressWarehouseLogisticsCountryGt;
  /**
   * 收货国家/地区 比较(gte)
   */
  private Long addressWarehouseLogisticsCountryGte;
  /**
   * 收货国家/地区 比较(lt)
   */
  private Long addressWarehouseLogisticsCountryLt;
  /**
   * 收货国家/地区 比较(lte)
   */
  private Long addressWarehouseLogisticsCountryLte;
  /**
   * 收货国家/地区 比较(contains)
   */
  private Long addressWarehouseLogisticsCountryContains;
  /**
   * 收货国家/地区 比较(notcontains)
   */
  private Long addressWarehouseLogisticsCountryNotcontains;
  /**
   * 收货国家/地区 比较(startswith)
   */
  private Long addressWarehouseLogisticsCountryStartswith;
  /**
   * 收货国家/地区 比较(endswith)
   */
  private Long addressWarehouseLogisticsCountryEndswith;
  /**
   * 收货国家/地区 比较(isnull)
   */
  private Boolean addressWarehouseLogisticsCountryIsnull;
  /**
   * 收货国家/地区 比较(isnotnull)
   */
  private Boolean addressWarehouseLogisticsCountryIsnotnull;
  /**
   * 收货国家/地区的国家 比较(eq)
   */
  private String addressWarehouseLogisticsCountryCountryEq;
  /**
   * 收货国家/地区的国家 比较(neq)
   */
  private String addressWarehouseLogisticsCountryCountryNeq;
  /**
   * 收货国家/地区的国家 比较(gt)
   */
  private String addressWarehouseLogisticsCountryCountryGt;
  /**
   * 收货国家/地区的国家 比较(gte)
   */
  private String addressWarehouseLogisticsCountryCountryGte;
  /**
   * 收货国家/地区的国家 比较(lt)
   */
  private String addressWarehouseLogisticsCountryCountryLt;
  /**
   * 收货国家/地区的国家 比较(lte)
   */
  private String addressWarehouseLogisticsCountryCountryLte;
  /**
   * 收货国家/地区的国家 比较(contains)
   */
  private String addressWarehouseLogisticsCountryCountryContains;
  /**
   * 收货国家/地区的国家 比较(notcontains)
   */
  private String addressWarehouseLogisticsCountryCountryNotcontains;
  /**
   * 收货国家/地区的国家 比较(startswith)
   */
  private String addressWarehouseLogisticsCountryCountryStartswith;
  /**
   * 收货国家/地区的国家 比较(endswith)
   */
  private String addressWarehouseLogisticsCountryCountryEndswith;
  /**
   * 收货国家/地区的国家 比较(isnull)
   */
  private Boolean addressWarehouseLogisticsCountryCountryIsnull;
  /**
   * 收货国家/地区的国家 比较(isnotnull)
   */
  private Boolean addressWarehouseLogisticsCountryCountryIsnotnull;

  /**
   * 收货省/州(模糊搜索)
   */
  private String addressWarehouseLogisticsProvince;

  /**
   * 收货省/州 比较(eq)
   */
  private String addressWarehouseLogisticsProvinceEq;
  /**
   * 收货省/州 比较(neq)
   */
  private String addressWarehouseLogisticsProvinceNeq;
  /**
   * 收货省/州 比较(gt)
   */
  private String addressWarehouseLogisticsProvinceGt;
  /**
   * 收货省/州 比较(gte)
   */
  private String addressWarehouseLogisticsProvinceGte;
  /**
   * 收货省/州 比较(lt)
   */
  private String addressWarehouseLogisticsProvinceLt;
  /**
   * 收货省/州 比较(lte)
   */
  private String addressWarehouseLogisticsProvinceLte;
  /**
   * 收货省/州 比较(contains)
   */
  private String addressWarehouseLogisticsProvinceContains;
  /**
   * 收货省/州 比较(notcontains)
   */
  private String addressWarehouseLogisticsProvinceNotcontains;
  /**
   * 收货省/州 比较(startswith)
   */
  private String addressWarehouseLogisticsProvinceStartswith;
  /**
   * 收货省/州 比较(endswith)
   */
  private String addressWarehouseLogisticsProvinceEndswith;
  /**
   * 收货省/州 比较(isnull)
   */
  private Boolean addressWarehouseLogisticsProvinceIsnull;
  /**
   * 收货省/州 比较(isnotnull)
   */
  private Boolean addressWarehouseLogisticsProvinceIsnotnull;

  /**
   * 收货省/州(精确搜索)
   */
  private List<String> addressWarehouseLogisticsProvinceInList;

  /**
   * 收货城市(模糊搜索)
   */
  private String addressWarehouseLogisticsCity;

  /**
   * 收货城市 比较(eq)
   */
  private String addressWarehouseLogisticsCityEq;
  /**
   * 收货城市 比较(neq)
   */
  private String addressWarehouseLogisticsCityNeq;
  /**
   * 收货城市 比较(gt)
   */
  private String addressWarehouseLogisticsCityGt;
  /**
   * 收货城市 比较(gte)
   */
  private String addressWarehouseLogisticsCityGte;
  /**
   * 收货城市 比较(lt)
   */
  private String addressWarehouseLogisticsCityLt;
  /**
   * 收货城市 比较(lte)
   */
  private String addressWarehouseLogisticsCityLte;
  /**
   * 收货城市 比较(contains)
   */
  private String addressWarehouseLogisticsCityContains;
  /**
   * 收货城市 比较(notcontains)
   */
  private String addressWarehouseLogisticsCityNotcontains;
  /**
   * 收货城市 比较(startswith)
   */
  private String addressWarehouseLogisticsCityStartswith;
  /**
   * 收货城市 比较(endswith)
   */
  private String addressWarehouseLogisticsCityEndswith;
  /**
   * 收货城市 比较(isnull)
   */
  private Boolean addressWarehouseLogisticsCityIsnull;
  /**
   * 收货城市 比较(isnotnull)
   */
  private Boolean addressWarehouseLogisticsCityIsnotnull;

  /**
   * 收货城市(精确搜索)
   */
  private List<String> addressWarehouseLogisticsCityInList;

  /**
   * 收货邮编开头(模糊搜索)
   */
  private String addressWarehouseLogisticsPostCodeStart;

  /**
   * 收货邮编开头 比较(eq)
   */
  private String addressWarehouseLogisticsPostCodeStartEq;
  /**
   * 收货邮编开头 比较(neq)
   */
  private String addressWarehouseLogisticsPostCodeStartNeq;
  /**
   * 收货邮编开头 比较(gt)
   */
  private String addressWarehouseLogisticsPostCodeStartGt;
  /**
   * 收货邮编开头 比较(gte)
   */
  private String addressWarehouseLogisticsPostCodeStartGte;
  /**
   * 收货邮编开头 比较(lt)
   */
  private String addressWarehouseLogisticsPostCodeStartLt;
  /**
   * 收货邮编开头 比较(lte)
   */
  private String addressWarehouseLogisticsPostCodeStartLte;
  /**
   * 收货邮编开头 比较(contains)
   */
  private String addressWarehouseLogisticsPostCodeStartContains;
  /**
   * 收货邮编开头 比较(notcontains)
   */
  private String addressWarehouseLogisticsPostCodeStartNotcontains;
  /**
   * 收货邮编开头 比较(startswith)
   */
  private String addressWarehouseLogisticsPostCodeStartStartswith;
  /**
   * 收货邮编开头 比较(endswith)
   */
  private String addressWarehouseLogisticsPostCodeStartEndswith;
  /**
   * 收货邮编开头 比较(isnull)
   */
  private Boolean addressWarehouseLogisticsPostCodeStartIsnull;
  /**
   * 收货邮编开头 比较(isnotnull)
   */
  private Boolean addressWarehouseLogisticsPostCodeStartIsnotnull;

  /**
   * 收货邮编开头(精确搜索)
   */
  private List<String> addressWarehouseLogisticsPostCodeStartInList;

  /**
   * 收货邮编包含(模糊搜索)
   */
  private String addressWarehouseLogisticsContains;

  /**
   * 收货邮编包含 比较(eq)
   */
  private String addressWarehouseLogisticsContainsEq;
  /**
   * 收货邮编包含 比较(neq)
   */
  private String addressWarehouseLogisticsContainsNeq;
  /**
   * 收货邮编包含 比较(gt)
   */
  private String addressWarehouseLogisticsContainsGt;
  /**
   * 收货邮编包含 比较(gte)
   */
  private String addressWarehouseLogisticsContainsGte;
  /**
   * 收货邮编包含 比较(lt)
   */
  private String addressWarehouseLogisticsContainsLt;
  /**
   * 收货邮编包含 比较(lte)
   */
  private String addressWarehouseLogisticsContainsLte;
  /**
   * 收货邮编包含 比较(contains)
   */
  private String addressWarehouseLogisticsContainsContains;
  /**
   * 收货邮编包含 比较(notcontains)
   */
  private String addressWarehouseLogisticsContainsNotcontains;
  /**
   * 收货邮编包含 比较(startswith)
   */
  private String addressWarehouseLogisticsContainsStartswith;
  /**
   * 收货邮编包含 比较(endswith)
   */
  private String addressWarehouseLogisticsContainsEndswith;
  /**
   * 收货邮编包含 比较(isnull)
   */
  private Boolean addressWarehouseLogisticsContainsIsnull;
  /**
   * 收货邮编包含 比较(isnotnull)
   */
  private Boolean addressWarehouseLogisticsContainsIsnotnull;

  /**
   * 收货邮编包含(精确搜索)
   */
  private List<String> addressWarehouseLogisticsContainsInList;

  /**
   * 两项满足其中一项
   */
  private String addressWarehouseLogisticsChooseOne;

  /**
   * 两项满足其中一项 比较(eq)
   */
  private String addressWarehouseLogisticsChooseOneEq;
  /**
   * 两项满足其中一项 比较(neq)
   */
  private String addressWarehouseLogisticsChooseOneNeq;
  /**
   * 两项满足其中一项 比较(gt)
   */
  private String addressWarehouseLogisticsChooseOneGt;
  /**
   * 两项满足其中一项 比较(gte)
   */
  private String addressWarehouseLogisticsChooseOneGte;
  /**
   * 两项满足其中一项 比较(lt)
   */
  private String addressWarehouseLogisticsChooseOneLt;
  /**
   * 两项满足其中一项 比较(lte)
   */
  private String addressWarehouseLogisticsChooseOneLte;
  /**
   * 两项满足其中一项 比较(contains)
   */
  private String addressWarehouseLogisticsChooseOneContains;
  /**
   * 两项满足其中一项 比较(notcontains)
   */
  private String addressWarehouseLogisticsChooseOneNotcontains;
  /**
   * 两项满足其中一项 比较(startswith)
   */
  private String addressWarehouseLogisticsChooseOneStartswith;
  /**
   * 两项满足其中一项 比较(endswith)
   */
  private String addressWarehouseLogisticsChooseOneEndswith;
  /**
   * 两项满足其中一项 比较(isnull)
   */
  private Boolean addressWarehouseLogisticsChooseOneIsnull;
  /**
   * 两项满足其中一项 比较(isnotnull)
   */
  private Boolean addressWarehouseLogisticsChooseOneIsnotnull;

  /**
   * 两项满足其中一项(精确搜索)
   */
  private List<String> addressWarehouseLogisticsChooseOneInList;

  /**
   * 指定收货邮编(模糊搜索)
   */
  private String addressWarehouseLogisticsBlack;

  /**
   * 指定收货邮编 比较(eq)
   */
  private String addressWarehouseLogisticsBlackEq;
  /**
   * 指定收货邮编 比较(neq)
   */
  private String addressWarehouseLogisticsBlackNeq;
  /**
   * 指定收货邮编 比较(gt)
   */
  private String addressWarehouseLogisticsBlackGt;
  /**
   * 指定收货邮编 比较(gte)
   */
  private String addressWarehouseLogisticsBlackGte;
  /**
   * 指定收货邮编 比较(lt)
   */
  private String addressWarehouseLogisticsBlackLt;
  /**
   * 指定收货邮编 比较(lte)
   */
  private String addressWarehouseLogisticsBlackLte;
  /**
   * 指定收货邮编 比较(contains)
   */
  private String addressWarehouseLogisticsBlackContains;
  /**
   * 指定收货邮编 比较(notcontains)
   */
  private String addressWarehouseLogisticsBlackNotcontains;
  /**
   * 指定收货邮编 比较(startswith)
   */
  private String addressWarehouseLogisticsBlackStartswith;
  /**
   * 指定收货邮编 比较(endswith)
   */
  private String addressWarehouseLogisticsBlackEndswith;
  /**
   * 指定收货邮编 比较(isnull)
   */
  private Boolean addressWarehouseLogisticsBlackIsnull;
  /**
   * 指定收货邮编 比较(isnotnull)
   */
  private Boolean addressWarehouseLogisticsBlackIsnotnull;

  /**
   * 指定收货邮编(精确搜索)
   */
  private List<String> addressWarehouseLogisticsBlackInList;

  /**
   * 地址类型
   */
  private String addressWarehouseLogisticsAddressType;

  /**
   * 地址类型 比较(eq)
   */
  private String addressWarehouseLogisticsAddressTypeEq;
  /**
   * 地址类型 比较(neq)
   */
  private String addressWarehouseLogisticsAddressTypeNeq;
  /**
   * 地址类型 比较(gt)
   */
  private String addressWarehouseLogisticsAddressTypeGt;
  /**
   * 地址类型 比较(gte)
   */
  private String addressWarehouseLogisticsAddressTypeGte;
  /**
   * 地址类型 比较(lt)
   */
  private String addressWarehouseLogisticsAddressTypeLt;
  /**
   * 地址类型 比较(lte)
   */
  private String addressWarehouseLogisticsAddressTypeLte;
  /**
   * 地址类型 比较(contains)
   */
  private String addressWarehouseLogisticsAddressTypeContains;
  /**
   * 地址类型 比较(notcontains)
   */
  private String addressWarehouseLogisticsAddressTypeNotcontains;
  /**
   * 地址类型 比较(startswith)
   */
  private String addressWarehouseLogisticsAddressTypeStartswith;
  /**
   * 地址类型 比较(endswith)
   */
  private String addressWarehouseLogisticsAddressTypeEndswith;
  /**
   * 地址类型 比较(isnull)
   */
  private Boolean addressWarehouseLogisticsAddressTypeIsnull;
  /**
   * 地址类型 比较(isnotnull)
   */
  private Boolean addressWarehouseLogisticsAddressTypeIsnotnull;

  /**
   * 地址类型(精确搜索)
   */
  private List<String> addressWarehouseLogisticsAddressTypeInList;

  /**
   * 订单产品
   */
  private Long addressOrderProduct;

  /**
   * 订单产品 比较(eq)
   */
  private Long addressOrderProductEq;
  /**
   * 订单产品 比较(neq)
   */
  private Long addressOrderProductNeq;
  /**
   * 订单产品 比较(gt)
   */
  private Long addressOrderProductGt;
  /**
   * 订单产品 比较(gte)
   */
  private Long addressOrderProductGte;
  /**
   * 订单产品 比较(lt)
   */
  private Long addressOrderProductLt;
  /**
   * 订单产品 比较(lte)
   */
  private Long addressOrderProductLte;
  /**
   * 订单产品 比较(contains)
   */
  private Long addressOrderProductContains;
  /**
   * 订单产品 比较(notcontains)
   */
  private Long addressOrderProductNotcontains;
  /**
   * 订单产品 比较(startswith)
   */
  private Long addressOrderProductStartswith;
  /**
   * 订单产品 比较(endswith)
   */
  private Long addressOrderProductEndswith;
  /**
   * 订单产品 比较(isnull)
   */
  private Boolean addressOrderProductIsnull;
  /**
   * 订单产品 比较(isnotnull)
   */
  private Boolean addressOrderProductIsnotnull;
  /**
   * 订单产品的品名 比较(eq)
   */
  private String addressOrderProductNameEq;
  /**
   * 订单产品的品名 比较(neq)
   */
  private String addressOrderProductNameNeq;
  /**
   * 订单产品的品名 比较(gt)
   */
  private String addressOrderProductNameGt;
  /**
   * 订单产品的品名 比较(gte)
   */
  private String addressOrderProductNameGte;
  /**
   * 订单产品的品名 比较(lt)
   */
  private String addressOrderProductNameLt;
  /**
   * 订单产品的品名 比较(lte)
   */
  private String addressOrderProductNameLte;
  /**
   * 订单产品的品名 比较(contains)
   */
  private String addressOrderProductNameContains;
  /**
   * 订单产品的品名 比较(notcontains)
   */
  private String addressOrderProductNameNotcontains;
  /**
   * 订单产品的品名 比较(startswith)
   */
  private String addressOrderProductNameStartswith;
  /**
   * 订单产品的品名 比较(endswith)
   */
  private String addressOrderProductNameEndswith;
  /**
   * 订单产品的品名 比较(isnull)
   */
  private Boolean addressOrderProductNameIsnull;
  /**
   * 订单产品的品名 比较(isnotnull)
   */
  private Boolean addressOrderProductNameIsnotnull;

  /**
   * 产品分类
   */
  private Long addressOrderProductClassify;

  /**
   * 产品分类 比较(eq)
   */
  private Long addressOrderProductClassifyEq;
  /**
   * 产品分类 比较(neq)
   */
  private Long addressOrderProductClassifyNeq;
  /**
   * 产品分类 比较(gt)
   */
  private Long addressOrderProductClassifyGt;
  /**
   * 产品分类 比较(gte)
   */
  private Long addressOrderProductClassifyGte;
  /**
   * 产品分类 比较(lt)
   */
  private Long addressOrderProductClassifyLt;
  /**
   * 产品分类 比较(lte)
   */
  private Long addressOrderProductClassifyLte;
  /**
   * 产品分类 比较(contains)
   */
  private Long addressOrderProductClassifyContains;
  /**
   * 产品分类 比较(notcontains)
   */
  private Long addressOrderProductClassifyNotcontains;
  /**
   * 产品分类 比较(startswith)
   */
  private Long addressOrderProductClassifyStartswith;
  /**
   * 产品分类 比较(endswith)
   */
  private Long addressOrderProductClassifyEndswith;
  /**
   * 产品分类 比较(isnull)
   */
  private Boolean addressOrderProductClassifyIsnull;
  /**
   * 产品分类 比较(isnotnull)
   */
  private Boolean addressOrderProductClassifyIsnotnull;
  /**
   * 产品分类的分类名称 比较(eq)
   */
  private String addressOrderProductClassifyNameEq;
  /**
   * 产品分类的分类名称 比较(neq)
   */
  private String addressOrderProductClassifyNameNeq;
  /**
   * 产品分类的分类名称 比较(gt)
   */
  private String addressOrderProductClassifyNameGt;
  /**
   * 产品分类的分类名称 比较(gte)
   */
  private String addressOrderProductClassifyNameGte;
  /**
   * 产品分类的分类名称 比较(lt)
   */
  private String addressOrderProductClassifyNameLt;
  /**
   * 产品分类的分类名称 比较(lte)
   */
  private String addressOrderProductClassifyNameLte;
  /**
   * 产品分类的分类名称 比较(contains)
   */
  private String addressOrderProductClassifyNameContains;
  /**
   * 产品分类的分类名称 比较(notcontains)
   */
  private String addressOrderProductClassifyNameNotcontains;
  /**
   * 产品分类的分类名称 比较(startswith)
   */
  private String addressOrderProductClassifyNameStartswith;
  /**
   * 产品分类的分类名称 比较(endswith)
   */
  private String addressOrderProductClassifyNameEndswith;
  /**
   * 产品分类的分类名称 比较(isnull)
   */
  private Boolean addressOrderProductClassifyNameIsnull;
  /**
   * 产品分类的分类名称 比较(isnotnull)
   */
  private Boolean addressOrderProductClassifyNameIsnotnull;

  /**
   * 产品数量
   */
  private String addressOrderMode;

  /**
   * 产品数量 比较(eq)
   */
  private String addressOrderModeEq;
  /**
   * 产品数量 比较(neq)
   */
  private String addressOrderModeNeq;
  /**
   * 产品数量 比较(gt)
   */
  private String addressOrderModeGt;
  /**
   * 产品数量 比较(gte)
   */
  private String addressOrderModeGte;
  /**
   * 产品数量 比较(lt)
   */
  private String addressOrderModeLt;
  /**
   * 产品数量 比较(lte)
   */
  private String addressOrderModeLte;
  /**
   * 产品数量 比较(contains)
   */
  private String addressOrderModeContains;
  /**
   * 产品数量 比较(notcontains)
   */
  private String addressOrderModeNotcontains;
  /**
   * 产品数量 比较(startswith)
   */
  private String addressOrderModeStartswith;
  /**
   * 产品数量 比较(endswith)
   */
  private String addressOrderModeEndswith;
  /**
   * 产品数量 比较(isnull)
   */
  private Boolean addressOrderModeIsnull;
  /**
   * 产品数量 比较(isnotnull)
   */
  private Boolean addressOrderModeIsnotnull;

  /**
   * 产品数量(精确搜索)
   */
  private List<String> addressOrderModeInList;

  /**
   * 总数量(模糊搜索)
   */
  private String addressOrderTotal;

  /**
   * 总数量 比较(eq)
   */
  private String addressOrderTotalEq;
  /**
   * 总数量 比较(neq)
   */
  private String addressOrderTotalNeq;
  /**
   * 总数量 比较(gt)
   */
  private String addressOrderTotalGt;
  /**
   * 总数量 比较(gte)
   */
  private String addressOrderTotalGte;
  /**
   * 总数量 比较(lt)
   */
  private String addressOrderTotalLt;
  /**
   * 总数量 比较(lte)
   */
  private String addressOrderTotalLte;
  /**
   * 总数量 比较(contains)
   */
  private String addressOrderTotalContains;
  /**
   * 总数量 比较(notcontains)
   */
  private String addressOrderTotalNotcontains;
  /**
   * 总数量 比较(startswith)
   */
  private String addressOrderTotalStartswith;
  /**
   * 总数量 比较(endswith)
   */
  private String addressOrderTotalEndswith;
  /**
   * 总数量 比较(isnull)
   */
  private Boolean addressOrderTotalIsnull;
  /**
   * 总数量 比较(isnotnull)
   */
  private Boolean addressOrderTotalIsnotnull;

  /**
   * 总数量(精确搜索)
   */
  private List<String> addressOrderTotalInList;

  /**
   * Sku数量(模糊搜索)
   */
  private String addressOrderSkuTotal;

  /**
   * Sku数量 比较(eq)
   */
  private String addressOrderSkuTotalEq;
  /**
   * Sku数量 比较(neq)
   */
  private String addressOrderSkuTotalNeq;
  /**
   * Sku数量 比较(gt)
   */
  private String addressOrderSkuTotalGt;
  /**
   * Sku数量 比较(gte)
   */
  private String addressOrderSkuTotalGte;
  /**
   * Sku数量 比较(lt)
   */
  private String addressOrderSkuTotalLt;
  /**
   * Sku数量 比较(lte)
   */
  private String addressOrderSkuTotalLte;
  /**
   * Sku数量 比较(contains)
   */
  private String addressOrderSkuTotalContains;
  /**
   * Sku数量 比较(notcontains)
   */
  private String addressOrderSkuTotalNotcontains;
  /**
   * Sku数量 比较(startswith)
   */
  private String addressOrderSkuTotalStartswith;
  /**
   * Sku数量 比较(endswith)
   */
  private String addressOrderSkuTotalEndswith;
  /**
   * Sku数量 比较(isnull)
   */
  private Boolean addressOrderSkuTotalIsnull;
  /**
   * Sku数量 比较(isnotnull)
   */
  private Boolean addressOrderSkuTotalIsnotnull;

  /**
   * Sku数量(精确搜索)
   */
  private List<String> addressOrderSkuTotalInList;

  /**
   * 估算重量(模糊搜索)
   */
  private String addressOrderThinkWeight;

  /**
   * 估算重量 比较(eq)
   */
  private String addressOrderThinkWeightEq;
  /**
   * 估算重量 比较(neq)
   */
  private String addressOrderThinkWeightNeq;
  /**
   * 估算重量 比较(gt)
   */
  private String addressOrderThinkWeightGt;
  /**
   * 估算重量 比较(gte)
   */
  private String addressOrderThinkWeightGte;
  /**
   * 估算重量 比较(lt)
   */
  private String addressOrderThinkWeightLt;
  /**
   * 估算重量 比较(lte)
   */
  private String addressOrderThinkWeightLte;
  /**
   * 估算重量 比较(contains)
   */
  private String addressOrderThinkWeightContains;
  /**
   * 估算重量 比较(notcontains)
   */
  private String addressOrderThinkWeightNotcontains;
  /**
   * 估算重量 比较(startswith)
   */
  private String addressOrderThinkWeightStartswith;
  /**
   * 估算重量 比较(endswith)
   */
  private String addressOrderThinkWeightEndswith;
  /**
   * 估算重量 比较(isnull)
   */
  private Boolean addressOrderThinkWeightIsnull;
  /**
   * 估算重量 比较(isnotnull)
   */
  private Boolean addressOrderThinkWeightIsnotnull;

  /**
   * 估算重量(精确搜索)
   */
  private List<String> addressOrderThinkWeightInList;

  /**
   * 估算尺寸(模糊搜索)
   */
  private String addressOrderThinkSize;

  /**
   * 估算尺寸 比较(eq)
   */
  private String addressOrderThinkSizeEq;
  /**
   * 估算尺寸 比较(neq)
   */
  private String addressOrderThinkSizeNeq;
  /**
   * 估算尺寸 比较(gt)
   */
  private String addressOrderThinkSizeGt;
  /**
   * 估算尺寸 比较(gte)
   */
  private String addressOrderThinkSizeGte;
  /**
   * 估算尺寸 比较(lt)
   */
  private String addressOrderThinkSizeLt;
  /**
   * 估算尺寸 比较(lte)
   */
  private String addressOrderThinkSizeLte;
  /**
   * 估算尺寸 比较(contains)
   */
  private String addressOrderThinkSizeContains;
  /**
   * 估算尺寸 比较(notcontains)
   */
  private String addressOrderThinkSizeNotcontains;
  /**
   * 估算尺寸 比较(startswith)
   */
  private String addressOrderThinkSizeStartswith;
  /**
   * 估算尺寸 比较(endswith)
   */
  private String addressOrderThinkSizeEndswith;
  /**
   * 估算尺寸 比较(isnull)
   */
  private Boolean addressOrderThinkSizeIsnull;
  /**
   * 估算尺寸 比较(isnotnull)
   */
  private Boolean addressOrderThinkSizeIsnotnull;

  /**
   * 估算尺寸(精确搜索)
   */
  private List<String> addressOrderThinkSizeInList;

  /**
   * 订单总金额(模糊搜索)
   */
  private String addressOrderTotalAmount;

  /**
   * 订单总金额 比较(eq)
   */
  private String addressOrderTotalAmountEq;
  /**
   * 订单总金额 比较(neq)
   */
  private String addressOrderTotalAmountNeq;
  /**
   * 订单总金额 比较(gt)
   */
  private String addressOrderTotalAmountGt;
  /**
   * 订单总金额 比较(gte)
   */
  private String addressOrderTotalAmountGte;
  /**
   * 订单总金额 比较(lt)
   */
  private String addressOrderTotalAmountLt;
  /**
   * 订单总金额 比较(lte)
   */
  private String addressOrderTotalAmountLte;
  /**
   * 订单总金额 比较(contains)
   */
  private String addressOrderTotalAmountContains;
  /**
   * 订单总金额 比较(notcontains)
   */
  private String addressOrderTotalAmountNotcontains;
  /**
   * 订单总金额 比较(startswith)
   */
  private String addressOrderTotalAmountStartswith;
  /**
   * 订单总金额 比较(endswith)
   */
  private String addressOrderTotalAmountEndswith;
  /**
   * 订单总金额 比较(isnull)
   */
  private Boolean addressOrderTotalAmountIsnull;
  /**
   * 订单总金额 比较(isnotnull)
   */
  private Boolean addressOrderTotalAmountIsnotnull;

  /**
   * 订单总金额(精确搜索)
   */
  private List<String> addressOrderTotalAmountInList;

  /**
   * 产品状态
   */
  private String addressOrderStatus;

  /**
   * 产品状态 比较(eq)
   */
  private String addressOrderStatusEq;
  /**
   * 产品状态 比较(neq)
   */
  private String addressOrderStatusNeq;
  /**
   * 产品状态 比较(gt)
   */
  private String addressOrderStatusGt;
  /**
   * 产品状态 比较(gte)
   */
  private String addressOrderStatusGte;
  /**
   * 产品状态 比较(lt)
   */
  private String addressOrderStatusLt;
  /**
   * 产品状态 比较(lte)
   */
  private String addressOrderStatusLte;
  /**
   * 产品状态 比较(contains)
   */
  private String addressOrderStatusContains;
  /**
   * 产品状态 比较(notcontains)
   */
  private String addressOrderStatusNotcontains;
  /**
   * 产品状态 比较(startswith)
   */
  private String addressOrderStatusStartswith;
  /**
   * 产品状态 比较(endswith)
   */
  private String addressOrderStatusEndswith;
  /**
   * 产品状态 比较(isnull)
   */
  private Boolean addressOrderStatusIsnull;
  /**
   * 产品状态 比较(isnotnull)
   */
  private Boolean addressOrderStatusIsnotnull;

  /**
   * 产品状态(精确搜索)
   */
  private List<String> addressOrderStatusInList;

  /**
   * 客选物流
   */
  private Long addressOrderLogistics;

  /**
   * 客选物流 比较(eq)
   */
  private Long addressOrderLogisticsEq;
  /**
   * 客选物流 比较(neq)
   */
  private Long addressOrderLogisticsNeq;
  /**
   * 客选物流 比较(gt)
   */
  private Long addressOrderLogisticsGt;
  /**
   * 客选物流 比较(gte)
   */
  private Long addressOrderLogisticsGte;
  /**
   * 客选物流 比较(lt)
   */
  private Long addressOrderLogisticsLt;
  /**
   * 客选物流 比较(lte)
   */
  private Long addressOrderLogisticsLte;
  /**
   * 客选物流 比较(contains)
   */
  private Long addressOrderLogisticsContains;
  /**
   * 客选物流 比较(notcontains)
   */
  private Long addressOrderLogisticsNotcontains;
  /**
   * 客选物流 比较(startswith)
   */
  private Long addressOrderLogisticsStartswith;
  /**
   * 客选物流 比较(endswith)
   */
  private Long addressOrderLogisticsEndswith;
  /**
   * 客选物流 比较(isnull)
   */
  private Boolean addressOrderLogisticsIsnull;
  /**
   * 客选物流 比较(isnotnull)
   */
  private Boolean addressOrderLogisticsIsnotnull;
  /**
   * 客选物流的名称 比较(eq)
   */
  private String addressOrderLogisticsLabelEq;
  /**
   * 客选物流的名称 比较(neq)
   */
  private String addressOrderLogisticsLabelNeq;
  /**
   * 客选物流的名称 比较(gt)
   */
  private String addressOrderLogisticsLabelGt;
  /**
   * 客选物流的名称 比较(gte)
   */
  private String addressOrderLogisticsLabelGte;
  /**
   * 客选物流的名称 比较(lt)
   */
  private String addressOrderLogisticsLabelLt;
  /**
   * 客选物流的名称 比较(lte)
   */
  private String addressOrderLogisticsLabelLte;
  /**
   * 客选物流的名称 比较(contains)
   */
  private String addressOrderLogisticsLabelContains;
  /**
   * 客选物流的名称 比较(notcontains)
   */
  private String addressOrderLogisticsLabelNotcontains;
  /**
   * 客选物流的名称 比较(startswith)
   */
  private String addressOrderLogisticsLabelStartswith;
  /**
   * 客选物流的名称 比较(endswith)
   */
  private String addressOrderLogisticsLabelEndswith;
  /**
   * 客选物流的名称 比较(isnull)
   */
  private Boolean addressOrderLogisticsLabelIsnull;
  /**
   * 客选物流的名称 比较(isnotnull)
   */
  private Boolean addressOrderLogisticsLabelIsnotnull;

  /**
   * 最早发货截止时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date addressOrderEndTimeStart;

  /**
   * 最晚发货截止时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date addressOrderEndTimeEnd;

  /**
   * 发货截止时间 比较(eq)
   */
  private Date addressOrderEndTimeEq;
  /**
   * 发货截止时间 比较(neq)
   */
  private Date addressOrderEndTimeNeq;
  /**
   * 发货截止时间 比较(gt)
   */
  private Date addressOrderEndTimeGt;
  /**
   * 发货截止时间 比较(gte)
   */
  private Date addressOrderEndTimeGte;
  /**
   * 发货截止时间 比较(lt)
   */
  private Date addressOrderEndTimeLt;
  /**
   * 发货截止时间 比较(lte)
   */
  private Date addressOrderEndTimeLte;
  /**
   * 发货截止时间 比较(contains)
   */
  private Date addressOrderEndTimeContains;
  /**
   * 发货截止时间 比较(notcontains)
   */
  private Date addressOrderEndTimeNotcontains;
  /**
   * 发货截止时间 比较(startswith)
   */
  private Date addressOrderEndTimeStartswith;
  /**
   * 发货截止时间 比较(endswith)
   */
  private Date addressOrderEndTimeEndswith;
  /**
   * 发货截止时间 比较(isnull)
   */
  private Boolean addressOrderEndTimeIsnull;
  /**
   * 发货截止时间 比较(isnotnull)
   */
  private Boolean addressOrderEndTimeIsnotnull;

  /**
   * 特殊属性
   */
  private String addressOrderSpecial;

  /**
   * 特殊属性 比较(eq)
   */
  private String addressOrderSpecialEq;
  /**
   * 特殊属性 比较(neq)
   */
  private String addressOrderSpecialNeq;
  /**
   * 特殊属性 比较(gt)
   */
  private String addressOrderSpecialGt;
  /**
   * 特殊属性 比较(gte)
   */
  private String addressOrderSpecialGte;
  /**
   * 特殊属性 比较(lt)
   */
  private String addressOrderSpecialLt;
  /**
   * 特殊属性 比较(lte)
   */
  private String addressOrderSpecialLte;
  /**
   * 特殊属性 比较(contains)
   */
  private String addressOrderSpecialContains;
  /**
   * 特殊属性 比较(notcontains)
   */
  private String addressOrderSpecialNotcontains;
  /**
   * 特殊属性 比较(startswith)
   */
  private String addressOrderSpecialStartswith;
  /**
   * 特殊属性 比较(endswith)
   */
  private String addressOrderSpecialEndswith;
  /**
   * 特殊属性 比较(isnull)
   */
  private Boolean addressOrderSpecialIsnull;
  /**
   * 特殊属性 比较(isnotnull)
   */
  private Boolean addressOrderSpecialIsnotnull;

  /**
   * 特殊属性(精确搜索)
   */
  private List<String> addressOrderSpecialInList;

  /**
   * 毛利润率(模糊搜索)
   */
  private String addressOrderGrossMargin;

  /**
   * 毛利润率 比较(eq)
   */
  private String addressOrderGrossMarginEq;
  /**
   * 毛利润率 比较(neq)
   */
  private String addressOrderGrossMarginNeq;
  /**
   * 毛利润率 比较(gt)
   */
  private String addressOrderGrossMarginGt;
  /**
   * 毛利润率 比较(gte)
   */
  private String addressOrderGrossMarginGte;
  /**
   * 毛利润率 比较(lt)
   */
  private String addressOrderGrossMarginLt;
  /**
   * 毛利润率 比较(lte)
   */
  private String addressOrderGrossMarginLte;
  /**
   * 毛利润率 比较(contains)
   */
  private String addressOrderGrossMarginContains;
  /**
   * 毛利润率 比较(notcontains)
   */
  private String addressOrderGrossMarginNotcontains;
  /**
   * 毛利润率 比较(startswith)
   */
  private String addressOrderGrossMarginStartswith;
  /**
   * 毛利润率 比较(endswith)
   */
  private String addressOrderGrossMarginEndswith;
  /**
   * 毛利润率 比较(isnull)
   */
  private Boolean addressOrderGrossMarginIsnull;
  /**
   * 毛利润率 比较(isnotnull)
   */
  private Boolean addressOrderGrossMarginIsnotnull;

  /**
   * 毛利润率(精确搜索)
   */
  private List<String> addressOrderGrossMarginInList;

  /**
   * 省州、城市为空填充
   */
  private String addressActFill;

  /**
   * 省州、城市为空填充 比较(eq)
   */
  private String addressActFillEq;
  /**
   * 省州、城市为空填充 比较(neq)
   */
  private String addressActFillNeq;
  /**
   * 省州、城市为空填充 比较(gt)
   */
  private String addressActFillGt;
  /**
   * 省州、城市为空填充 比较(gte)
   */
  private String addressActFillGte;
  /**
   * 省州、城市为空填充 比较(lt)
   */
  private String addressActFillLt;
  /**
   * 省州、城市为空填充 比较(lte)
   */
  private String addressActFillLte;
  /**
   * 省州、城市为空填充 比较(contains)
   */
  private String addressActFillContains;
  /**
   * 省州、城市为空填充 比较(notcontains)
   */
  private String addressActFillNotcontains;
  /**
   * 省州、城市为空填充 比较(startswith)
   */
  private String addressActFillStartswith;
  /**
   * 省州、城市为空填充 比较(endswith)
   */
  private String addressActFillEndswith;
  /**
   * 省州、城市为空填充 比较(isnull)
   */
  private Boolean addressActFillIsnull;
  /**
   * 省州、城市为空填充 比较(isnotnull)
   */
  private Boolean addressActFillIsnotnull;

  /**
   * 省州、城市为空填充(精确搜索)
   */
  private List<String> addressActFillInList;

  /**
   * 省州全称/简称替换
   */
  private String addressActSelectQJ;

  /**
   * 省州全称/简称替换 比较(eq)
   */
  private String addressActSelectQJEq;
  /**
   * 省州全称/简称替换 比较(neq)
   */
  private String addressActSelectQJNeq;
  /**
   * 省州全称/简称替换 比较(gt)
   */
  private String addressActSelectQJGt;
  /**
   * 省州全称/简称替换 比较(gte)
   */
  private String addressActSelectQJGte;
  /**
   * 省州全称/简称替换 比较(lt)
   */
  private String addressActSelectQJLt;
  /**
   * 省州全称/简称替换 比较(lte)
   */
  private String addressActSelectQJLte;
  /**
   * 省州全称/简称替换 比较(contains)
   */
  private String addressActSelectQJContains;
  /**
   * 省州全称/简称替换 比较(notcontains)
   */
  private String addressActSelectQJNotcontains;
  /**
   * 省州全称/简称替换 比较(startswith)
   */
  private String addressActSelectQJStartswith;
  /**
   * 省州全称/简称替换 比较(endswith)
   */
  private String addressActSelectQJEndswith;
  /**
   * 省州全称/简称替换 比较(isnull)
   */
  private Boolean addressActSelectQJIsnull;
  /**
   * 省州全称/简称替换 比较(isnotnull)
   */
  private Boolean addressActSelectQJIsnotnull;

  /**
   * 省州全称/简称替换(精确搜索)
   */
  private List<String> addressActSelectQJInList;

  /**
   * 门牌号解析1(模糊搜索)
   */
  private String addressActHouseNoAnalysis1;

  /**
   * 门牌号解析1 比较(eq)
   */
  private String addressActHouseNoAnalysis1Eq;
  /**
   * 门牌号解析1 比较(neq)
   */
  private String addressActHouseNoAnalysis1Neq;
  /**
   * 门牌号解析1 比较(gt)
   */
  private String addressActHouseNoAnalysis1Gt;
  /**
   * 门牌号解析1 比较(gte)
   */
  private String addressActHouseNoAnalysis1Gte;
  /**
   * 门牌号解析1 比较(lt)
   */
  private String addressActHouseNoAnalysis1Lt;
  /**
   * 门牌号解析1 比较(lte)
   */
  private String addressActHouseNoAnalysis1Lte;
  /**
   * 门牌号解析1 比较(contains)
   */
  private String addressActHouseNoAnalysis1Contains;
  /**
   * 门牌号解析1 比较(notcontains)
   */
  private String addressActHouseNoAnalysis1Notcontains;
  /**
   * 门牌号解析1 比较(startswith)
   */
  private String addressActHouseNoAnalysis1Startswith;
  /**
   * 门牌号解析1 比较(endswith)
   */
  private String addressActHouseNoAnalysis1Endswith;
  /**
   * 门牌号解析1 比较(isnull)
   */
  private Boolean addressActHouseNoAnalysis1Isnull;
  /**
   * 门牌号解析1 比较(isnotnull)
   */
  private Boolean addressActHouseNoAnalysis1Isnotnull;

  /**
   * 门牌号解析1(精确搜索)
   */
  private List<String> addressActHouseNoAnalysis1InList;

  /**
   * 门牌号解析2(模糊搜索)
   */
  private String addressActHouseNoAnalysis2;

  /**
   * 门牌号解析2 比较(eq)
   */
  private String addressActHouseNoAnalysis2Eq;
  /**
   * 门牌号解析2 比较(neq)
   */
  private String addressActHouseNoAnalysis2Neq;
  /**
   * 门牌号解析2 比较(gt)
   */
  private String addressActHouseNoAnalysis2Gt;
  /**
   * 门牌号解析2 比较(gte)
   */
  private String addressActHouseNoAnalysis2Gte;
  /**
   * 门牌号解析2 比较(lt)
   */
  private String addressActHouseNoAnalysis2Lt;
  /**
   * 门牌号解析2 比较(lte)
   */
  private String addressActHouseNoAnalysis2Lte;
  /**
   * 门牌号解析2 比较(contains)
   */
  private String addressActHouseNoAnalysis2Contains;
  /**
   * 门牌号解析2 比较(notcontains)
   */
  private String addressActHouseNoAnalysis2Notcontains;
  /**
   * 门牌号解析2 比较(startswith)
   */
  private String addressActHouseNoAnalysis2Startswith;
  /**
   * 门牌号解析2 比较(endswith)
   */
  private String addressActHouseNoAnalysis2Endswith;
  /**
   * 门牌号解析2 比较(isnull)
   */
  private Boolean addressActHouseNoAnalysis2Isnull;
  /**
   * 门牌号解析2 比较(isnotnull)
   */
  private Boolean addressActHouseNoAnalysis2Isnotnull;

  /**
   * 门牌号解析2(精确搜索)
   */
  private List<String> addressActHouseNoAnalysis2InList;

  /**
   * 门牌号解析3(模糊搜索)
   */
  private String addressActHouseNoAnalysis3;

  /**
   * 门牌号解析3 比较(eq)
   */
  private String addressActHouseNoAnalysis3Eq;
  /**
   * 门牌号解析3 比较(neq)
   */
  private String addressActHouseNoAnalysis3Neq;
  /**
   * 门牌号解析3 比较(gt)
   */
  private String addressActHouseNoAnalysis3Gt;
  /**
   * 门牌号解析3 比较(gte)
   */
  private String addressActHouseNoAnalysis3Gte;
  /**
   * 门牌号解析3 比较(lt)
   */
  private String addressActHouseNoAnalysis3Lt;
  /**
   * 门牌号解析3 比较(lte)
   */
  private String addressActHouseNoAnalysis3Lte;
  /**
   * 门牌号解析3 比较(contains)
   */
  private String addressActHouseNoAnalysis3Contains;
  /**
   * 门牌号解析3 比较(notcontains)
   */
  private String addressActHouseNoAnalysis3Notcontains;
  /**
   * 门牌号解析3 比较(startswith)
   */
  private String addressActHouseNoAnalysis3Startswith;
  /**
   * 门牌号解析3 比较(endswith)
   */
  private String addressActHouseNoAnalysis3Endswith;
  /**
   * 门牌号解析3 比较(isnull)
   */
  private Boolean addressActHouseNoAnalysis3Isnull;
  /**
   * 门牌号解析3 比较(isnotnull)
   */
  private Boolean addressActHouseNoAnalysis3Isnotnull;

  /**
   * 门牌号解析3(精确搜索)
   */
  private List<String> addressActHouseNoAnalysis3InList;

  /**
   * 电话号码简化1(模糊搜索)
   */
  private String addressActPhoneSimplify1;

  /**
   * 电话号码简化1 比较(eq)
   */
  private String addressActPhoneSimplify1Eq;
  /**
   * 电话号码简化1 比较(neq)
   */
  private String addressActPhoneSimplify1Neq;
  /**
   * 电话号码简化1 比较(gt)
   */
  private String addressActPhoneSimplify1Gt;
  /**
   * 电话号码简化1 比较(gte)
   */
  private String addressActPhoneSimplify1Gte;
  /**
   * 电话号码简化1 比较(lt)
   */
  private String addressActPhoneSimplify1Lt;
  /**
   * 电话号码简化1 比较(lte)
   */
  private String addressActPhoneSimplify1Lte;
  /**
   * 电话号码简化1 比较(contains)
   */
  private String addressActPhoneSimplify1Contains;
  /**
   * 电话号码简化1 比较(notcontains)
   */
  private String addressActPhoneSimplify1Notcontains;
  /**
   * 电话号码简化1 比较(startswith)
   */
  private String addressActPhoneSimplify1Startswith;
  /**
   * 电话号码简化1 比较(endswith)
   */
  private String addressActPhoneSimplify1Endswith;
  /**
   * 电话号码简化1 比较(isnull)
   */
  private Boolean addressActPhoneSimplify1Isnull;
  /**
   * 电话号码简化1 比较(isnotnull)
   */
  private Boolean addressActPhoneSimplify1Isnotnull;

  /**
   * 电话号码简化1(精确搜索)
   */
  private List<String> addressActPhoneSimplify1InList;

  /**
   * 电话号码简化2(模糊搜索)
   */
  private String addressActPhoneSimplify2;

  /**
   * 电话号码简化2 比较(eq)
   */
  private String addressActPhoneSimplify2Eq;
  /**
   * 电话号码简化2 比较(neq)
   */
  private String addressActPhoneSimplify2Neq;
  /**
   * 电话号码简化2 比较(gt)
   */
  private String addressActPhoneSimplify2Gt;
  /**
   * 电话号码简化2 比较(gte)
   */
  private String addressActPhoneSimplify2Gte;
  /**
   * 电话号码简化2 比较(lt)
   */
  private String addressActPhoneSimplify2Lt;
  /**
   * 电话号码简化2 比较(lte)
   */
  private String addressActPhoneSimplify2Lte;
  /**
   * 电话号码简化2 比较(contains)
   */
  private String addressActPhoneSimplify2Contains;
  /**
   * 电话号码简化2 比较(notcontains)
   */
  private String addressActPhoneSimplify2Notcontains;
  /**
   * 电话号码简化2 比较(startswith)
   */
  private String addressActPhoneSimplify2Startswith;
  /**
   * 电话号码简化2 比较(endswith)
   */
  private String addressActPhoneSimplify2Endswith;
  /**
   * 电话号码简化2 比较(isnull)
   */
  private Boolean addressActPhoneSimplify2Isnull;
  /**
   * 电话号码简化2 比较(isnotnull)
   */
  private Boolean addressActPhoneSimplify2Isnotnull;

  /**
   * 电话号码简化2(精确搜索)
   */
  private List<String> addressActPhoneSimplify2InList;

  /**
   * 电话号码简化3(模糊搜索)
   */
  private String addressActPhoneSimplify3;

  /**
   * 电话号码简化3 比较(eq)
   */
  private String addressActPhoneSimplify3Eq;
  /**
   * 电话号码简化3 比较(neq)
   */
  private String addressActPhoneSimplify3Neq;
  /**
   * 电话号码简化3 比较(gt)
   */
  private String addressActPhoneSimplify3Gt;
  /**
   * 电话号码简化3 比较(gte)
   */
  private String addressActPhoneSimplify3Gte;
  /**
   * 电话号码简化3 比较(lt)
   */
  private String addressActPhoneSimplify3Lt;
  /**
   * 电话号码简化3 比较(lte)
   */
  private String addressActPhoneSimplify3Lte;
  /**
   * 电话号码简化3 比较(contains)
   */
  private String addressActPhoneSimplify3Contains;
  /**
   * 电话号码简化3 比较(notcontains)
   */
  private String addressActPhoneSimplify3Notcontains;
  /**
   * 电话号码简化3 比较(startswith)
   */
  private String addressActPhoneSimplify3Startswith;
  /**
   * 电话号码简化3 比较(endswith)
   */
  private String addressActPhoneSimplify3Endswith;
  /**
   * 电话号码简化3 比较(isnull)
   */
  private Boolean addressActPhoneSimplify3Isnull;
  /**
   * 电话号码简化3 比较(isnotnull)
   */
  private Boolean addressActPhoneSimplify3Isnotnull;

  /**
   * 电话号码简化3(精确搜索)
   */
  private List<String> addressActPhoneSimplify3InList;

  /**
   * 电话号码简化4(模糊搜索)
   */
  private String addressActPhoneSimplify4;

  /**
   * 电话号码简化4 比较(eq)
   */
  private String addressActPhoneSimplify4Eq;
  /**
   * 电话号码简化4 比较(neq)
   */
  private String addressActPhoneSimplify4Neq;
  /**
   * 电话号码简化4 比较(gt)
   */
  private String addressActPhoneSimplify4Gt;
  /**
   * 电话号码简化4 比较(gte)
   */
  private String addressActPhoneSimplify4Gte;
  /**
   * 电话号码简化4 比较(lt)
   */
  private String addressActPhoneSimplify4Lt;
  /**
   * 电话号码简化4 比较(lte)
   */
  private String addressActPhoneSimplify4Lte;
  /**
   * 电话号码简化4 比较(contains)
   */
  private String addressActPhoneSimplify4Contains;
  /**
   * 电话号码简化4 比较(notcontains)
   */
  private String addressActPhoneSimplify4Notcontains;
  /**
   * 电话号码简化4 比较(startswith)
   */
  private String addressActPhoneSimplify4Startswith;
  /**
   * 电话号码简化4 比较(endswith)
   */
  private String addressActPhoneSimplify4Endswith;
  /**
   * 电话号码简化4 比较(isnull)
   */
  private Boolean addressActPhoneSimplify4Isnull;
  /**
   * 电话号码简化4 比较(isnotnull)
   */
  private Boolean addressActPhoneSimplify4Isnotnull;

  /**
   * 电话号码简化4(精确搜索)
   */
  private List<String> addressActPhoneSimplify4InList;

  /**
   * 邮编处理1(模糊搜索)
   */
  private String addressActPostHandle1;

  /**
   * 邮编处理1 比较(eq)
   */
  private String addressActPostHandle1Eq;
  /**
   * 邮编处理1 比较(neq)
   */
  private String addressActPostHandle1Neq;
  /**
   * 邮编处理1 比较(gt)
   */
  private String addressActPostHandle1Gt;
  /**
   * 邮编处理1 比较(gte)
   */
  private String addressActPostHandle1Gte;
  /**
   * 邮编处理1 比较(lt)
   */
  private String addressActPostHandle1Lt;
  /**
   * 邮编处理1 比较(lte)
   */
  private String addressActPostHandle1Lte;
  /**
   * 邮编处理1 比较(contains)
   */
  private String addressActPostHandle1Contains;
  /**
   * 邮编处理1 比较(notcontains)
   */
  private String addressActPostHandle1Notcontains;
  /**
   * 邮编处理1 比较(startswith)
   */
  private String addressActPostHandle1Startswith;
  /**
   * 邮编处理1 比较(endswith)
   */
  private String addressActPostHandle1Endswith;
  /**
   * 邮编处理1 比较(isnull)
   */
  private Boolean addressActPostHandle1Isnull;
  /**
   * 邮编处理1 比较(isnotnull)
   */
  private Boolean addressActPostHandle1Isnotnull;

  /**
   * 邮编处理1(精确搜索)
   */
  private List<String> addressActPostHandle1InList;

  /**
   * 邮编处理2(模糊搜索)
   */
  private String addressActPostHandle2;

  /**
   * 邮编处理2 比较(eq)
   */
  private String addressActPostHandle2Eq;
  /**
   * 邮编处理2 比较(neq)
   */
  private String addressActPostHandle2Neq;
  /**
   * 邮编处理2 比较(gt)
   */
  private String addressActPostHandle2Gt;
  /**
   * 邮编处理2 比较(gte)
   */
  private String addressActPostHandle2Gte;
  /**
   * 邮编处理2 比较(lt)
   */
  private String addressActPostHandle2Lt;
  /**
   * 邮编处理2 比较(lte)
   */
  private String addressActPostHandle2Lte;
  /**
   * 邮编处理2 比较(contains)
   */
  private String addressActPostHandle2Contains;
  /**
   * 邮编处理2 比较(notcontains)
   */
  private String addressActPostHandle2Notcontains;
  /**
   * 邮编处理2 比较(startswith)
   */
  private String addressActPostHandle2Startswith;
  /**
   * 邮编处理2 比较(endswith)
   */
  private String addressActPostHandle2Endswith;
  /**
   * 邮编处理2 比较(isnull)
   */
  private Boolean addressActPostHandle2Isnull;
  /**
   * 邮编处理2 比较(isnotnull)
   */
  private Boolean addressActPostHandle2Isnotnull;

  /**
   * 邮编处理2(精确搜索)
   */
  private List<String> addressActPostHandle2InList;

  /**
   * 订单来源
   */
  private String processBaseSource;

  /**
   * 订单来源 比较(eq)
   */
  private String processBaseSourceEq;
  /**
   * 订单来源 比较(neq)
   */
  private String processBaseSourceNeq;
  /**
   * 订单来源 比较(gt)
   */
  private String processBaseSourceGt;
  /**
   * 订单来源 比较(gte)
   */
  private String processBaseSourceGte;
  /**
   * 订单来源 比较(lt)
   */
  private String processBaseSourceLt;
  /**
   * 订单来源 比较(lte)
   */
  private String processBaseSourceLte;
  /**
   * 订单来源 比较(contains)
   */
  private String processBaseSourceContains;
  /**
   * 订单来源 比较(notcontains)
   */
  private String processBaseSourceNotcontains;
  /**
   * 订单来源 比较(startswith)
   */
  private String processBaseSourceStartswith;
  /**
   * 订单来源 比较(endswith)
   */
  private String processBaseSourceEndswith;
  /**
   * 订单来源 比较(isnull)
   */
  private Boolean processBaseSourceIsnull;
  /**
   * 订单来源 比较(isnotnull)
   */
  private Boolean processBaseSourceIsnotnull;

  /**
   * 订单来源(精确搜索)
   */
  private List<String> processBaseSourceInList;

  /**
   * 订单平台
   */
  private String processBaseOrderPlatform;

  /**
   * 订单平台 比较(eq)
   */
  private String processBaseOrderPlatformEq;
  /**
   * 订单平台 比较(neq)
   */
  private String processBaseOrderPlatformNeq;
  /**
   * 订单平台 比较(gt)
   */
  private String processBaseOrderPlatformGt;
  /**
   * 订单平台 比较(gte)
   */
  private String processBaseOrderPlatformGte;
  /**
   * 订单平台 比较(lt)
   */
  private String processBaseOrderPlatformLt;
  /**
   * 订单平台 比较(lte)
   */
  private String processBaseOrderPlatformLte;
  /**
   * 订单平台 比较(contains)
   */
  private String processBaseOrderPlatformContains;
  /**
   * 订单平台 比较(notcontains)
   */
  private String processBaseOrderPlatformNotcontains;
  /**
   * 订单平台 比较(startswith)
   */
  private String processBaseOrderPlatformStartswith;
  /**
   * 订单平台 比较(endswith)
   */
  private String processBaseOrderPlatformEndswith;
  /**
   * 订单平台 比较(isnull)
   */
  private Boolean processBaseOrderPlatformIsnull;
  /**
   * 订单平台 比较(isnotnull)
   */
  private Boolean processBaseOrderPlatformIsnotnull;

  /**
   * 订单平台(精确搜索)
   */
  private List<String> processBaseOrderPlatformInList;

  /**
   * 订单站点
   */
  private Long processBaseOrderSite;

  /**
   * 订单站点 比较(eq)
   */
  private Long processBaseOrderSiteEq;
  /**
   * 订单站点 比较(neq)
   */
  private Long processBaseOrderSiteNeq;
  /**
   * 订单站点 比较(gt)
   */
  private Long processBaseOrderSiteGt;
  /**
   * 订单站点 比较(gte)
   */
  private Long processBaseOrderSiteGte;
  /**
   * 订单站点 比较(lt)
   */
  private Long processBaseOrderSiteLt;
  /**
   * 订单站点 比较(lte)
   */
  private Long processBaseOrderSiteLte;
  /**
   * 订单站点 比较(contains)
   */
  private Long processBaseOrderSiteContains;
  /**
   * 订单站点 比较(notcontains)
   */
  private Long processBaseOrderSiteNotcontains;
  /**
   * 订单站点 比较(startswith)
   */
  private Long processBaseOrderSiteStartswith;
  /**
   * 订单站点 比较(endswith)
   */
  private Long processBaseOrderSiteEndswith;
  /**
   * 订单站点 比较(isnull)
   */
  private Boolean processBaseOrderSiteIsnull;
  /**
   * 订单站点 比较(isnotnull)
   */
  private Boolean processBaseOrderSiteIsnotnull;
  /**
   * 订单站点的名称 比较(eq)
   */
  private String processBaseOrderSiteNameEq;
  /**
   * 订单站点的名称 比较(neq)
   */
  private String processBaseOrderSiteNameNeq;
  /**
   * 订单站点的名称 比较(gt)
   */
  private String processBaseOrderSiteNameGt;
  /**
   * 订单站点的名称 比较(gte)
   */
  private String processBaseOrderSiteNameGte;
  /**
   * 订单站点的名称 比较(lt)
   */
  private String processBaseOrderSiteNameLt;
  /**
   * 订单站点的名称 比较(lte)
   */
  private String processBaseOrderSiteNameLte;
  /**
   * 订单站点的名称 比较(contains)
   */
  private String processBaseOrderSiteNameContains;
  /**
   * 订单站点的名称 比较(notcontains)
   */
  private String processBaseOrderSiteNameNotcontains;
  /**
   * 订单站点的名称 比较(startswith)
   */
  private String processBaseOrderSiteNameStartswith;
  /**
   * 订单站点的名称 比较(endswith)
   */
  private String processBaseOrderSiteNameEndswith;
  /**
   * 订单站点的名称 比较(isnull)
   */
  private Boolean processBaseOrderSiteNameIsnull;
  /**
   * 订单站点的名称 比较(isnotnull)
   */
  private Boolean processBaseOrderSiteNameIsnotnull;

  /**
   * 订单店铺
   */
  private Long processBaseOrderShopInfo;

  /**
   * 订单店铺 比较(eq)
   */
  private Long processBaseOrderShopInfoEq;
  /**
   * 订单店铺 比较(neq)
   */
  private Long processBaseOrderShopInfoNeq;
  /**
   * 订单店铺 比较(gt)
   */
  private Long processBaseOrderShopInfoGt;
  /**
   * 订单店铺 比较(gte)
   */
  private Long processBaseOrderShopInfoGte;
  /**
   * 订单店铺 比较(lt)
   */
  private Long processBaseOrderShopInfoLt;
  /**
   * 订单店铺 比较(lte)
   */
  private Long processBaseOrderShopInfoLte;
  /**
   * 订单店铺 比较(contains)
   */
  private Long processBaseOrderShopInfoContains;
  /**
   * 订单店铺 比较(notcontains)
   */
  private Long processBaseOrderShopInfoNotcontains;
  /**
   * 订单店铺 比较(startswith)
   */
  private Long processBaseOrderShopInfoStartswith;
  /**
   * 订单店铺 比较(endswith)
   */
  private Long processBaseOrderShopInfoEndswith;
  /**
   * 订单店铺 比较(isnull)
   */
  private Boolean processBaseOrderShopInfoIsnull;
  /**
   * 订单店铺 比较(isnotnull)
   */
  private Boolean processBaseOrderShopInfoIsnotnull;
  /**
   * 订单店铺的名称 比较(eq)
   */
  private String processBaseOrderShopInfoShopNameEq;
  /**
   * 订单店铺的名称 比较(neq)
   */
  private String processBaseOrderShopInfoShopNameNeq;
  /**
   * 订单店铺的名称 比较(gt)
   */
  private String processBaseOrderShopInfoShopNameGt;
  /**
   * 订单店铺的名称 比较(gte)
   */
  private String processBaseOrderShopInfoShopNameGte;
  /**
   * 订单店铺的名称 比较(lt)
   */
  private String processBaseOrderShopInfoShopNameLt;
  /**
   * 订单店铺的名称 比较(lte)
   */
  private String processBaseOrderShopInfoShopNameLte;
  /**
   * 订单店铺的名称 比较(contains)
   */
  private String processBaseOrderShopInfoShopNameContains;
  /**
   * 订单店铺的名称 比较(notcontains)
   */
  private String processBaseOrderShopInfoShopNameNotcontains;
  /**
   * 订单店铺的名称 比较(startswith)
   */
  private String processBaseOrderShopInfoShopNameStartswith;
  /**
   * 订单店铺的名称 比较(endswith)
   */
  private String processBaseOrderShopInfoShopNameEndswith;
  /**
   * 订单店铺的名称 比较(isnull)
   */
  private Boolean processBaseOrderShopInfoShopNameIsnull;
  /**
   * 订单店铺的名称 比较(isnotnull)
   */
  private Boolean processBaseOrderShopInfoShopNameIsnotnull;

  /**
   * 发货仓库
   */
  private Long processWarehouseLogisticsDeliveryWarehouse;

  /**
   * 发货仓库 比较(eq)
   */
  private Long processWarehouseLogisticsDeliveryWarehouseEq;
  /**
   * 发货仓库 比较(neq)
   */
  private Long processWarehouseLogisticsDeliveryWarehouseNeq;
  /**
   * 发货仓库 比较(gt)
   */
  private Long processWarehouseLogisticsDeliveryWarehouseGt;
  /**
   * 发货仓库 比较(gte)
   */
  private Long processWarehouseLogisticsDeliveryWarehouseGte;
  /**
   * 发货仓库 比较(lt)
   */
  private Long processWarehouseLogisticsDeliveryWarehouseLt;
  /**
   * 发货仓库 比较(lte)
   */
  private Long processWarehouseLogisticsDeliveryWarehouseLte;
  /**
   * 发货仓库 比较(contains)
   */
  private Long processWarehouseLogisticsDeliveryWarehouseContains;
  /**
   * 发货仓库 比较(notcontains)
   */
  private Long processWarehouseLogisticsDeliveryWarehouseNotcontains;
  /**
   * 发货仓库 比较(startswith)
   */
  private Long processWarehouseLogisticsDeliveryWarehouseStartswith;
  /**
   * 发货仓库 比较(endswith)
   */
  private Long processWarehouseLogisticsDeliveryWarehouseEndswith;
  /**
   * 发货仓库 比较(isnull)
   */
  private Boolean processWarehouseLogisticsDeliveryWarehouseIsnull;
  /**
   * 发货仓库 比较(isnotnull)
   */
  private Boolean processWarehouseLogisticsDeliveryWarehouseIsnotnull;
  /**
   * 发货仓库的仓库名称 比较(eq)
   */
  private String processWarehouseLogisticsDeliveryWarehouseNameEq;
  /**
   * 发货仓库的仓库名称 比较(neq)
   */
  private String processWarehouseLogisticsDeliveryWarehouseNameNeq;
  /**
   * 发货仓库的仓库名称 比较(gt)
   */
  private String processWarehouseLogisticsDeliveryWarehouseNameGt;
  /**
   * 发货仓库的仓库名称 比较(gte)
   */
  private String processWarehouseLogisticsDeliveryWarehouseNameGte;
  /**
   * 发货仓库的仓库名称 比较(lt)
   */
  private String processWarehouseLogisticsDeliveryWarehouseNameLt;
  /**
   * 发货仓库的仓库名称 比较(lte)
   */
  private String processWarehouseLogisticsDeliveryWarehouseNameLte;
  /**
   * 发货仓库的仓库名称 比较(contains)
   */
  private String processWarehouseLogisticsDeliveryWarehouseNameContains;
  /**
   * 发货仓库的仓库名称 比较(notcontains)
   */
  private String processWarehouseLogisticsDeliveryWarehouseNameNotcontains;
  /**
   * 发货仓库的仓库名称 比较(startswith)
   */
  private String processWarehouseLogisticsDeliveryWarehouseNameStartswith;
  /**
   * 发货仓库的仓库名称 比较(endswith)
   */
  private String processWarehouseLogisticsDeliveryWarehouseNameEndswith;
  /**
   * 发货仓库的仓库名称 比较(isnull)
   */
  private Boolean processWarehouseLogisticsDeliveryWarehouseNameIsnull;
  /**
   * 发货仓库的仓库名称 比较(isnotnull)
   */
  private Boolean processWarehouseLogisticsDeliveryWarehouseNameIsnotnull;

  /**
   * 物流商
   */
  private Long processWarehouseLogisticsProvider;

  /**
   * 物流商 比较(eq)
   */
  private Long processWarehouseLogisticsProviderEq;
  /**
   * 物流商 比较(neq)
   */
  private Long processWarehouseLogisticsProviderNeq;
  /**
   * 物流商 比较(gt)
   */
  private Long processWarehouseLogisticsProviderGt;
  /**
   * 物流商 比较(gte)
   */
  private Long processWarehouseLogisticsProviderGte;
  /**
   * 物流商 比较(lt)
   */
  private Long processWarehouseLogisticsProviderLt;
  /**
   * 物流商 比较(lte)
   */
  private Long processWarehouseLogisticsProviderLte;
  /**
   * 物流商 比较(contains)
   */
  private Long processWarehouseLogisticsProviderContains;
  /**
   * 物流商 比较(notcontains)
   */
  private Long processWarehouseLogisticsProviderNotcontains;
  /**
   * 物流商 比较(startswith)
   */
  private Long processWarehouseLogisticsProviderStartswith;
  /**
   * 物流商 比较(endswith)
   */
  private Long processWarehouseLogisticsProviderEndswith;
  /**
   * 物流商 比较(isnull)
   */
  private Boolean processWarehouseLogisticsProviderIsnull;
  /**
   * 物流商 比较(isnotnull)
   */
  private Boolean processWarehouseLogisticsProviderIsnotnull;
  /**
   * 物流商的名称 比较(eq)
   */
  private String processWarehouseLogisticsProviderLabelEq;
  /**
   * 物流商的名称 比较(neq)
   */
  private String processWarehouseLogisticsProviderLabelNeq;
  /**
   * 物流商的名称 比较(gt)
   */
  private String processWarehouseLogisticsProviderLabelGt;
  /**
   * 物流商的名称 比较(gte)
   */
  private String processWarehouseLogisticsProviderLabelGte;
  /**
   * 物流商的名称 比较(lt)
   */
  private String processWarehouseLogisticsProviderLabelLt;
  /**
   * 物流商的名称 比较(lte)
   */
  private String processWarehouseLogisticsProviderLabelLte;
  /**
   * 物流商的名称 比较(contains)
   */
  private String processWarehouseLogisticsProviderLabelContains;
  /**
   * 物流商的名称 比较(notcontains)
   */
  private String processWarehouseLogisticsProviderLabelNotcontains;
  /**
   * 物流商的名称 比较(startswith)
   */
  private String processWarehouseLogisticsProviderLabelStartswith;
  /**
   * 物流商的名称 比较(endswith)
   */
  private String processWarehouseLogisticsProviderLabelEndswith;
  /**
   * 物流商的名称 比较(isnull)
   */
  private Boolean processWarehouseLogisticsProviderLabelIsnull;
  /**
   * 物流商的名称 比较(isnotnull)
   */
  private Boolean processWarehouseLogisticsProviderLabelIsnotnull;

  /**
   * 物流方式
   */
  private Long processWarehouseLogisticsChannel;

  /**
   * 物流方式 比较(eq)
   */
  private Long processWarehouseLogisticsChannelEq;
  /**
   * 物流方式 比较(neq)
   */
  private Long processWarehouseLogisticsChannelNeq;
  /**
   * 物流方式 比较(gt)
   */
  private Long processWarehouseLogisticsChannelGt;
  /**
   * 物流方式 比较(gte)
   */
  private Long processWarehouseLogisticsChannelGte;
  /**
   * 物流方式 比较(lt)
   */
  private Long processWarehouseLogisticsChannelLt;
  /**
   * 物流方式 比较(lte)
   */
  private Long processWarehouseLogisticsChannelLte;
  /**
   * 物流方式 比较(contains)
   */
  private Long processWarehouseLogisticsChannelContains;
  /**
   * 物流方式 比较(notcontains)
   */
  private Long processWarehouseLogisticsChannelNotcontains;
  /**
   * 物流方式 比较(startswith)
   */
  private Long processWarehouseLogisticsChannelStartswith;
  /**
   * 物流方式 比较(endswith)
   */
  private Long processWarehouseLogisticsChannelEndswith;
  /**
   * 物流方式 比较(isnull)
   */
  private Boolean processWarehouseLogisticsChannelIsnull;
  /**
   * 物流方式 比较(isnotnull)
   */
  private Boolean processWarehouseLogisticsChannelIsnotnull;
  /**
   * 物流方式的名称 比较(eq)
   */
  private String processWarehouseLogisticsChannelLabelEq;
  /**
   * 物流方式的名称 比较(neq)
   */
  private String processWarehouseLogisticsChannelLabelNeq;
  /**
   * 物流方式的名称 比较(gt)
   */
  private String processWarehouseLogisticsChannelLabelGt;
  /**
   * 物流方式的名称 比较(gte)
   */
  private String processWarehouseLogisticsChannelLabelGte;
  /**
   * 物流方式的名称 比较(lt)
   */
  private String processWarehouseLogisticsChannelLabelLt;
  /**
   * 物流方式的名称 比较(lte)
   */
  private String processWarehouseLogisticsChannelLabelLte;
  /**
   * 物流方式的名称 比较(contains)
   */
  private String processWarehouseLogisticsChannelLabelContains;
  /**
   * 物流方式的名称 比较(notcontains)
   */
  private String processWarehouseLogisticsChannelLabelNotcontains;
  /**
   * 物流方式的名称 比较(startswith)
   */
  private String processWarehouseLogisticsChannelLabelStartswith;
  /**
   * 物流方式的名称 比较(endswith)
   */
  private String processWarehouseLogisticsChannelLabelEndswith;
  /**
   * 物流方式的名称 比较(isnull)
   */
  private Boolean processWarehouseLogisticsChannelLabelIsnull;
  /**
   * 物流方式的名称 比较(isnotnull)
   */
  private Boolean processWarehouseLogisticsChannelLabelIsnotnull;

  /**
   * 收货国家/地区
   */
  private Long processWarehouseLogisticsCountry;

  /**
   * 收货国家/地区 比较(eq)
   */
  private Long processWarehouseLogisticsCountryEq;
  /**
   * 收货国家/地区 比较(neq)
   */
  private Long processWarehouseLogisticsCountryNeq;
  /**
   * 收货国家/地区 比较(gt)
   */
  private Long processWarehouseLogisticsCountryGt;
  /**
   * 收货国家/地区 比较(gte)
   */
  private Long processWarehouseLogisticsCountryGte;
  /**
   * 收货国家/地区 比较(lt)
   */
  private Long processWarehouseLogisticsCountryLt;
  /**
   * 收货国家/地区 比较(lte)
   */
  private Long processWarehouseLogisticsCountryLte;
  /**
   * 收货国家/地区 比较(contains)
   */
  private Long processWarehouseLogisticsCountryContains;
  /**
   * 收货国家/地区 比较(notcontains)
   */
  private Long processWarehouseLogisticsCountryNotcontains;
  /**
   * 收货国家/地区 比较(startswith)
   */
  private Long processWarehouseLogisticsCountryStartswith;
  /**
   * 收货国家/地区 比较(endswith)
   */
  private Long processWarehouseLogisticsCountryEndswith;
  /**
   * 收货国家/地区 比较(isnull)
   */
  private Boolean processWarehouseLogisticsCountryIsnull;
  /**
   * 收货国家/地区 比较(isnotnull)
   */
  private Boolean processWarehouseLogisticsCountryIsnotnull;
  /**
   * 收货国家/地区的国家 比较(eq)
   */
  private String processWarehouseLogisticsCountryCountryEq;
  /**
   * 收货国家/地区的国家 比较(neq)
   */
  private String processWarehouseLogisticsCountryCountryNeq;
  /**
   * 收货国家/地区的国家 比较(gt)
   */
  private String processWarehouseLogisticsCountryCountryGt;
  /**
   * 收货国家/地区的国家 比较(gte)
   */
  private String processWarehouseLogisticsCountryCountryGte;
  /**
   * 收货国家/地区的国家 比较(lt)
   */
  private String processWarehouseLogisticsCountryCountryLt;
  /**
   * 收货国家/地区的国家 比较(lte)
   */
  private String processWarehouseLogisticsCountryCountryLte;
  /**
   * 收货国家/地区的国家 比较(contains)
   */
  private String processWarehouseLogisticsCountryCountryContains;
  /**
   * 收货国家/地区的国家 比较(notcontains)
   */
  private String processWarehouseLogisticsCountryCountryNotcontains;
  /**
   * 收货国家/地区的国家 比较(startswith)
   */
  private String processWarehouseLogisticsCountryCountryStartswith;
  /**
   * 收货国家/地区的国家 比较(endswith)
   */
  private String processWarehouseLogisticsCountryCountryEndswith;
  /**
   * 收货国家/地区的国家 比较(isnull)
   */
  private Boolean processWarehouseLogisticsCountryCountryIsnull;
  /**
   * 收货国家/地区的国家 比较(isnotnull)
   */
  private Boolean processWarehouseLogisticsCountryCountryIsnotnull;

  /**
   * 收货省/州(模糊搜索)
   */
  private String processWarehouseLogisticsProvince;

  /**
   * 收货省/州 比较(eq)
   */
  private String processWarehouseLogisticsProvinceEq;
  /**
   * 收货省/州 比较(neq)
   */
  private String processWarehouseLogisticsProvinceNeq;
  /**
   * 收货省/州 比较(gt)
   */
  private String processWarehouseLogisticsProvinceGt;
  /**
   * 收货省/州 比较(gte)
   */
  private String processWarehouseLogisticsProvinceGte;
  /**
   * 收货省/州 比较(lt)
   */
  private String processWarehouseLogisticsProvinceLt;
  /**
   * 收货省/州 比较(lte)
   */
  private String processWarehouseLogisticsProvinceLte;
  /**
   * 收货省/州 比较(contains)
   */
  private String processWarehouseLogisticsProvinceContains;
  /**
   * 收货省/州 比较(notcontains)
   */
  private String processWarehouseLogisticsProvinceNotcontains;
  /**
   * 收货省/州 比较(startswith)
   */
  private String processWarehouseLogisticsProvinceStartswith;
  /**
   * 收货省/州 比较(endswith)
   */
  private String processWarehouseLogisticsProvinceEndswith;
  /**
   * 收货省/州 比较(isnull)
   */
  private Boolean processWarehouseLogisticsProvinceIsnull;
  /**
   * 收货省/州 比较(isnotnull)
   */
  private Boolean processWarehouseLogisticsProvinceIsnotnull;

  /**
   * 收货省/州(精确搜索)
   */
  private List<String> processWarehouseLogisticsProvinceInList;

  /**
   * 收货城市(模糊搜索)
   */
  private String processWarehouseLogisticsCity;

  /**
   * 收货城市 比较(eq)
   */
  private String processWarehouseLogisticsCityEq;
  /**
   * 收货城市 比较(neq)
   */
  private String processWarehouseLogisticsCityNeq;
  /**
   * 收货城市 比较(gt)
   */
  private String processWarehouseLogisticsCityGt;
  /**
   * 收货城市 比较(gte)
   */
  private String processWarehouseLogisticsCityGte;
  /**
   * 收货城市 比较(lt)
   */
  private String processWarehouseLogisticsCityLt;
  /**
   * 收货城市 比较(lte)
   */
  private String processWarehouseLogisticsCityLte;
  /**
   * 收货城市 比较(contains)
   */
  private String processWarehouseLogisticsCityContains;
  /**
   * 收货城市 比较(notcontains)
   */
  private String processWarehouseLogisticsCityNotcontains;
  /**
   * 收货城市 比较(startswith)
   */
  private String processWarehouseLogisticsCityStartswith;
  /**
   * 收货城市 比较(endswith)
   */
  private String processWarehouseLogisticsCityEndswith;
  /**
   * 收货城市 比较(isnull)
   */
  private Boolean processWarehouseLogisticsCityIsnull;
  /**
   * 收货城市 比较(isnotnull)
   */
  private Boolean processWarehouseLogisticsCityIsnotnull;

  /**
   * 收货城市(精确搜索)
   */
  private List<String> processWarehouseLogisticsCityInList;

  /**
   * 收货邮编开头(模糊搜索)
   */
  private String processWarehouseLogisticsPostCodeStart;

  /**
   * 收货邮编开头 比较(eq)
   */
  private String processWarehouseLogisticsPostCodeStartEq;
  /**
   * 收货邮编开头 比较(neq)
   */
  private String processWarehouseLogisticsPostCodeStartNeq;
  /**
   * 收货邮编开头 比较(gt)
   */
  private String processWarehouseLogisticsPostCodeStartGt;
  /**
   * 收货邮编开头 比较(gte)
   */
  private String processWarehouseLogisticsPostCodeStartGte;
  /**
   * 收货邮编开头 比较(lt)
   */
  private String processWarehouseLogisticsPostCodeStartLt;
  /**
   * 收货邮编开头 比较(lte)
   */
  private String processWarehouseLogisticsPostCodeStartLte;
  /**
   * 收货邮编开头 比较(contains)
   */
  private String processWarehouseLogisticsPostCodeStartContains;
  /**
   * 收货邮编开头 比较(notcontains)
   */
  private String processWarehouseLogisticsPostCodeStartNotcontains;
  /**
   * 收货邮编开头 比较(startswith)
   */
  private String processWarehouseLogisticsPostCodeStartStartswith;
  /**
   * 收货邮编开头 比较(endswith)
   */
  private String processWarehouseLogisticsPostCodeStartEndswith;
  /**
   * 收货邮编开头 比较(isnull)
   */
  private Boolean processWarehouseLogisticsPostCodeStartIsnull;
  /**
   * 收货邮编开头 比较(isnotnull)
   */
  private Boolean processWarehouseLogisticsPostCodeStartIsnotnull;

  /**
   * 收货邮编开头(精确搜索)
   */
  private List<String> processWarehouseLogisticsPostCodeStartInList;

  /**
   * 收货邮编包含(模糊搜索)
   */
  private String processWarehouseLogisticsContains;

  /**
   * 收货邮编包含 比较(eq)
   */
  private String processWarehouseLogisticsContainsEq;
  /**
   * 收货邮编包含 比较(neq)
   */
  private String processWarehouseLogisticsContainsNeq;
  /**
   * 收货邮编包含 比较(gt)
   */
  private String processWarehouseLogisticsContainsGt;
  /**
   * 收货邮编包含 比较(gte)
   */
  private String processWarehouseLogisticsContainsGte;
  /**
   * 收货邮编包含 比较(lt)
   */
  private String processWarehouseLogisticsContainsLt;
  /**
   * 收货邮编包含 比较(lte)
   */
  private String processWarehouseLogisticsContainsLte;
  /**
   * 收货邮编包含 比较(contains)
   */
  private String processWarehouseLogisticsContainsContains;
  /**
   * 收货邮编包含 比较(notcontains)
   */
  private String processWarehouseLogisticsContainsNotcontains;
  /**
   * 收货邮编包含 比较(startswith)
   */
  private String processWarehouseLogisticsContainsStartswith;
  /**
   * 收货邮编包含 比较(endswith)
   */
  private String processWarehouseLogisticsContainsEndswith;
  /**
   * 收货邮编包含 比较(isnull)
   */
  private Boolean processWarehouseLogisticsContainsIsnull;
  /**
   * 收货邮编包含 比较(isnotnull)
   */
  private Boolean processWarehouseLogisticsContainsIsnotnull;

  /**
   * 收货邮编包含(精确搜索)
   */
  private List<String> processWarehouseLogisticsContainsInList;

  /**
   * 两项满足其中一项
   */
  private String processWarehouseLogisticsChooseOne;

  /**
   * 两项满足其中一项 比较(eq)
   */
  private String processWarehouseLogisticsChooseOneEq;
  /**
   * 两项满足其中一项 比较(neq)
   */
  private String processWarehouseLogisticsChooseOneNeq;
  /**
   * 两项满足其中一项 比较(gt)
   */
  private String processWarehouseLogisticsChooseOneGt;
  /**
   * 两项满足其中一项 比较(gte)
   */
  private String processWarehouseLogisticsChooseOneGte;
  /**
   * 两项满足其中一项 比较(lt)
   */
  private String processWarehouseLogisticsChooseOneLt;
  /**
   * 两项满足其中一项 比较(lte)
   */
  private String processWarehouseLogisticsChooseOneLte;
  /**
   * 两项满足其中一项 比较(contains)
   */
  private String processWarehouseLogisticsChooseOneContains;
  /**
   * 两项满足其中一项 比较(notcontains)
   */
  private String processWarehouseLogisticsChooseOneNotcontains;
  /**
   * 两项满足其中一项 比较(startswith)
   */
  private String processWarehouseLogisticsChooseOneStartswith;
  /**
   * 两项满足其中一项 比较(endswith)
   */
  private String processWarehouseLogisticsChooseOneEndswith;
  /**
   * 两项满足其中一项 比较(isnull)
   */
  private Boolean processWarehouseLogisticsChooseOneIsnull;
  /**
   * 两项满足其中一项 比较(isnotnull)
   */
  private Boolean processWarehouseLogisticsChooseOneIsnotnull;

  /**
   * 两项满足其中一项(精确搜索)
   */
  private List<String> processWarehouseLogisticsChooseOneInList;

  /**
   * 指定收货邮编(模糊搜索)
   */
  private String processWarehouseLogisticsBlack;

  /**
   * 指定收货邮编 比较(eq)
   */
  private String processWarehouseLogisticsBlackEq;
  /**
   * 指定收货邮编 比较(neq)
   */
  private String processWarehouseLogisticsBlackNeq;
  /**
   * 指定收货邮编 比较(gt)
   */
  private String processWarehouseLogisticsBlackGt;
  /**
   * 指定收货邮编 比较(gte)
   */
  private String processWarehouseLogisticsBlackGte;
  /**
   * 指定收货邮编 比较(lt)
   */
  private String processWarehouseLogisticsBlackLt;
  /**
   * 指定收货邮编 比较(lte)
   */
  private String processWarehouseLogisticsBlackLte;
  /**
   * 指定收货邮编 比较(contains)
   */
  private String processWarehouseLogisticsBlackContains;
  /**
   * 指定收货邮编 比较(notcontains)
   */
  private String processWarehouseLogisticsBlackNotcontains;
  /**
   * 指定收货邮编 比较(startswith)
   */
  private String processWarehouseLogisticsBlackStartswith;
  /**
   * 指定收货邮编 比较(endswith)
   */
  private String processWarehouseLogisticsBlackEndswith;
  /**
   * 指定收货邮编 比较(isnull)
   */
  private Boolean processWarehouseLogisticsBlackIsnull;
  /**
   * 指定收货邮编 比较(isnotnull)
   */
  private Boolean processWarehouseLogisticsBlackIsnotnull;

  /**
   * 指定收货邮编(精确搜索)
   */
  private List<String> processWarehouseLogisticsBlackInList;

  /**
   * 地址类型
   */
  private String processWarehouseLogisticsprocessType;

  /**
   * 地址类型 比较(eq)
   */
  private String processWarehouseLogisticsprocessTypeEq;
  /**
   * 地址类型 比较(neq)
   */
  private String processWarehouseLogisticsprocessTypeNeq;
  /**
   * 地址类型 比较(gt)
   */
  private String processWarehouseLogisticsprocessTypeGt;
  /**
   * 地址类型 比较(gte)
   */
  private String processWarehouseLogisticsprocessTypeGte;
  /**
   * 地址类型 比较(lt)
   */
  private String processWarehouseLogisticsprocessTypeLt;
  /**
   * 地址类型 比较(lte)
   */
  private String processWarehouseLogisticsprocessTypeLte;
  /**
   * 地址类型 比较(contains)
   */
  private String processWarehouseLogisticsprocessTypeContains;
  /**
   * 地址类型 比较(notcontains)
   */
  private String processWarehouseLogisticsprocessTypeNotcontains;
  /**
   * 地址类型 比较(startswith)
   */
  private String processWarehouseLogisticsprocessTypeStartswith;
  /**
   * 地址类型 比较(endswith)
   */
  private String processWarehouseLogisticsprocessTypeEndswith;
  /**
   * 地址类型 比较(isnull)
   */
  private Boolean processWarehouseLogisticsprocessTypeIsnull;
  /**
   * 地址类型 比较(isnotnull)
   */
  private Boolean processWarehouseLogisticsprocessTypeIsnotnull;

  /**
   * 地址类型(精确搜索)
   */
  private List<String> processWarehouseLogisticsprocessTypeInList;

  /**
   * 订单产品
   */
  private Long processOrderProduct;

  /**
   * 订单产品 比较(eq)
   */
  private Long processOrderProductEq;
  /**
   * 订单产品 比较(neq)
   */
  private Long processOrderProductNeq;
  /**
   * 订单产品 比较(gt)
   */
  private Long processOrderProductGt;
  /**
   * 订单产品 比较(gte)
   */
  private Long processOrderProductGte;
  /**
   * 订单产品 比较(lt)
   */
  private Long processOrderProductLt;
  /**
   * 订单产品 比较(lte)
   */
  private Long processOrderProductLte;
  /**
   * 订单产品 比较(contains)
   */
  private Long processOrderProductContains;
  /**
   * 订单产品 比较(notcontains)
   */
  private Long processOrderProductNotcontains;
  /**
   * 订单产品 比较(startswith)
   */
  private Long processOrderProductStartswith;
  /**
   * 订单产品 比较(endswith)
   */
  private Long processOrderProductEndswith;
  /**
   * 订单产品 比较(isnull)
   */
  private Boolean processOrderProductIsnull;
  /**
   * 订单产品 比较(isnotnull)
   */
  private Boolean processOrderProductIsnotnull;
  /**
   * 订单产品的品名 比较(eq)
   */
  private String processOrderProductNameEq;
  /**
   * 订单产品的品名 比较(neq)
   */
  private String processOrderProductNameNeq;
  /**
   * 订单产品的品名 比较(gt)
   */
  private String processOrderProductNameGt;
  /**
   * 订单产品的品名 比较(gte)
   */
  private String processOrderProductNameGte;
  /**
   * 订单产品的品名 比较(lt)
   */
  private String processOrderProductNameLt;
  /**
   * 订单产品的品名 比较(lte)
   */
  private String processOrderProductNameLte;
  /**
   * 订单产品的品名 比较(contains)
   */
  private String processOrderProductNameContains;
  /**
   * 订单产品的品名 比较(notcontains)
   */
  private String processOrderProductNameNotcontains;
  /**
   * 订单产品的品名 比较(startswith)
   */
  private String processOrderProductNameStartswith;
  /**
   * 订单产品的品名 比较(endswith)
   */
  private String processOrderProductNameEndswith;
  /**
   * 订单产品的品名 比较(isnull)
   */
  private Boolean processOrderProductNameIsnull;
  /**
   * 订单产品的品名 比较(isnotnull)
   */
  private Boolean processOrderProductNameIsnotnull;

  /**
   * 产品分类
   */
  private Long processOrderProductClassify;

  /**
   * 产品分类 比较(eq)
   */
  private Long processOrderProductClassifyEq;
  /**
   * 产品分类 比较(neq)
   */
  private Long processOrderProductClassifyNeq;
  /**
   * 产品分类 比较(gt)
   */
  private Long processOrderProductClassifyGt;
  /**
   * 产品分类 比较(gte)
   */
  private Long processOrderProductClassifyGte;
  /**
   * 产品分类 比较(lt)
   */
  private Long processOrderProductClassifyLt;
  /**
   * 产品分类 比较(lte)
   */
  private Long processOrderProductClassifyLte;
  /**
   * 产品分类 比较(contains)
   */
  private Long processOrderProductClassifyContains;
  /**
   * 产品分类 比较(notcontains)
   */
  private Long processOrderProductClassifyNotcontains;
  /**
   * 产品分类 比较(startswith)
   */
  private Long processOrderProductClassifyStartswith;
  /**
   * 产品分类 比较(endswith)
   */
  private Long processOrderProductClassifyEndswith;
  /**
   * 产品分类 比较(isnull)
   */
  private Boolean processOrderProductClassifyIsnull;
  /**
   * 产品分类 比较(isnotnull)
   */
  private Boolean processOrderProductClassifyIsnotnull;
  /**
   * 产品分类的分类名称 比较(eq)
   */
  private String processOrderProductClassifyNameEq;
  /**
   * 产品分类的分类名称 比较(neq)
   */
  private String processOrderProductClassifyNameNeq;
  /**
   * 产品分类的分类名称 比较(gt)
   */
  private String processOrderProductClassifyNameGt;
  /**
   * 产品分类的分类名称 比较(gte)
   */
  private String processOrderProductClassifyNameGte;
  /**
   * 产品分类的分类名称 比较(lt)
   */
  private String processOrderProductClassifyNameLt;
  /**
   * 产品分类的分类名称 比较(lte)
   */
  private String processOrderProductClassifyNameLte;
  /**
   * 产品分类的分类名称 比较(contains)
   */
  private String processOrderProductClassifyNameContains;
  /**
   * 产品分类的分类名称 比较(notcontains)
   */
  private String processOrderProductClassifyNameNotcontains;
  /**
   * 产品分类的分类名称 比较(startswith)
   */
  private String processOrderProductClassifyNameStartswith;
  /**
   * 产品分类的分类名称 比较(endswith)
   */
  private String processOrderProductClassifyNameEndswith;
  /**
   * 产品分类的分类名称 比较(isnull)
   */
  private Boolean processOrderProductClassifyNameIsnull;
  /**
   * 产品分类的分类名称 比较(isnotnull)
   */
  private Boolean processOrderProductClassifyNameIsnotnull;

  /**
   * 产品数量
   */
  private String processOrderMode;

  /**
   * 产品数量 比较(eq)
   */
  private String processOrderModeEq;
  /**
   * 产品数量 比较(neq)
   */
  private String processOrderModeNeq;
  /**
   * 产品数量 比较(gt)
   */
  private String processOrderModeGt;
  /**
   * 产品数量 比较(gte)
   */
  private String processOrderModeGte;
  /**
   * 产品数量 比较(lt)
   */
  private String processOrderModeLt;
  /**
   * 产品数量 比较(lte)
   */
  private String processOrderModeLte;
  /**
   * 产品数量 比较(contains)
   */
  private String processOrderModeContains;
  /**
   * 产品数量 比较(notcontains)
   */
  private String processOrderModeNotcontains;
  /**
   * 产品数量 比较(startswith)
   */
  private String processOrderModeStartswith;
  /**
   * 产品数量 比较(endswith)
   */
  private String processOrderModeEndswith;
  /**
   * 产品数量 比较(isnull)
   */
  private Boolean processOrderModeIsnull;
  /**
   * 产品数量 比较(isnotnull)
   */
  private Boolean processOrderModeIsnotnull;

  /**
   * 产品数量(精确搜索)
   */
  private List<String> processOrderModeInList;

  /**
   * 总数量(模糊搜索)
   */
  private String processOrderTotal;

  /**
   * 总数量 比较(eq)
   */
  private String processOrderTotalEq;
  /**
   * 总数量 比较(neq)
   */
  private String processOrderTotalNeq;
  /**
   * 总数量 比较(gt)
   */
  private String processOrderTotalGt;
  /**
   * 总数量 比较(gte)
   */
  private String processOrderTotalGte;
  /**
   * 总数量 比较(lt)
   */
  private String processOrderTotalLt;
  /**
   * 总数量 比较(lte)
   */
  private String processOrderTotalLte;
  /**
   * 总数量 比较(contains)
   */
  private String processOrderTotalContains;
  /**
   * 总数量 比较(notcontains)
   */
  private String processOrderTotalNotcontains;
  /**
   * 总数量 比较(startswith)
   */
  private String processOrderTotalStartswith;
  /**
   * 总数量 比较(endswith)
   */
  private String processOrderTotalEndswith;
  /**
   * 总数量 比较(isnull)
   */
  private Boolean processOrderTotalIsnull;
  /**
   * 总数量 比较(isnotnull)
   */
  private Boolean processOrderTotalIsnotnull;

  /**
   * 总数量(精确搜索)
   */
  private List<String> processOrderTotalInList;

  /**
   * Sku数量(模糊搜索)
   */
  private String processOrderSkuTotal;

  /**
   * Sku数量 比较(eq)
   */
  private String processOrderSkuTotalEq;
  /**
   * Sku数量 比较(neq)
   */
  private String processOrderSkuTotalNeq;
  /**
   * Sku数量 比较(gt)
   */
  private String processOrderSkuTotalGt;
  /**
   * Sku数量 比较(gte)
   */
  private String processOrderSkuTotalGte;
  /**
   * Sku数量 比较(lt)
   */
  private String processOrderSkuTotalLt;
  /**
   * Sku数量 比较(lte)
   */
  private String processOrderSkuTotalLte;
  /**
   * Sku数量 比较(contains)
   */
  private String processOrderSkuTotalContains;
  /**
   * Sku数量 比较(notcontains)
   */
  private String processOrderSkuTotalNotcontains;
  /**
   * Sku数量 比较(startswith)
   */
  private String processOrderSkuTotalStartswith;
  /**
   * Sku数量 比较(endswith)
   */
  private String processOrderSkuTotalEndswith;
  /**
   * Sku数量 比较(isnull)
   */
  private Boolean processOrderSkuTotalIsnull;
  /**
   * Sku数量 比较(isnotnull)
   */
  private Boolean processOrderSkuTotalIsnotnull;

  /**
   * Sku数量(精确搜索)
   */
  private List<String> processOrderSkuTotalInList;

  /**
   * 估算重量(模糊搜索)
   */
  private String processOrderThinkWeight;

  /**
   * 估算重量 比较(eq)
   */
  private String processOrderThinkWeightEq;
  /**
   * 估算重量 比较(neq)
   */
  private String processOrderThinkWeightNeq;
  /**
   * 估算重量 比较(gt)
   */
  private String processOrderThinkWeightGt;
  /**
   * 估算重量 比较(gte)
   */
  private String processOrderThinkWeightGte;
  /**
   * 估算重量 比较(lt)
   */
  private String processOrderThinkWeightLt;
  /**
   * 估算重量 比较(lte)
   */
  private String processOrderThinkWeightLte;
  /**
   * 估算重量 比较(contains)
   */
  private String processOrderThinkWeightContains;
  /**
   * 估算重量 比较(notcontains)
   */
  private String processOrderThinkWeightNotcontains;
  /**
   * 估算重量 比较(startswith)
   */
  private String processOrderThinkWeightStartswith;
  /**
   * 估算重量 比较(endswith)
   */
  private String processOrderThinkWeightEndswith;
  /**
   * 估算重量 比较(isnull)
   */
  private Boolean processOrderThinkWeightIsnull;
  /**
   * 估算重量 比较(isnotnull)
   */
  private Boolean processOrderThinkWeightIsnotnull;

  /**
   * 估算重量(精确搜索)
   */
  private List<String> processOrderThinkWeightInList;

  /**
   * 估算尺寸(模糊搜索)
   */
  private String processOrderThinkSize;

  /**
   * 估算尺寸 比较(eq)
   */
  private String processOrderThinkSizeEq;
  /**
   * 估算尺寸 比较(neq)
   */
  private String processOrderThinkSizeNeq;
  /**
   * 估算尺寸 比较(gt)
   */
  private String processOrderThinkSizeGt;
  /**
   * 估算尺寸 比较(gte)
   */
  private String processOrderThinkSizeGte;
  /**
   * 估算尺寸 比较(lt)
   */
  private String processOrderThinkSizeLt;
  /**
   * 估算尺寸 比较(lte)
   */
  private String processOrderThinkSizeLte;
  /**
   * 估算尺寸 比较(contains)
   */
  private String processOrderThinkSizeContains;
  /**
   * 估算尺寸 比较(notcontains)
   */
  private String processOrderThinkSizeNotcontains;
  /**
   * 估算尺寸 比较(startswith)
   */
  private String processOrderThinkSizeStartswith;
  /**
   * 估算尺寸 比较(endswith)
   */
  private String processOrderThinkSizeEndswith;
  /**
   * 估算尺寸 比较(isnull)
   */
  private Boolean processOrderThinkSizeIsnull;
  /**
   * 估算尺寸 比较(isnotnull)
   */
  private Boolean processOrderThinkSizeIsnotnull;

  /**
   * 估算尺寸(精确搜索)
   */
  private List<String> processOrderThinkSizeInList;

  /**
   * 订单总金额(模糊搜索)
   */
  private String processOrderTotalAmount;

  /**
   * 订单总金额 比较(eq)
   */
  private String processOrderTotalAmountEq;
  /**
   * 订单总金额 比较(neq)
   */
  private String processOrderTotalAmountNeq;
  /**
   * 订单总金额 比较(gt)
   */
  private String processOrderTotalAmountGt;
  /**
   * 订单总金额 比较(gte)
   */
  private String processOrderTotalAmountGte;
  /**
   * 订单总金额 比较(lt)
   */
  private String processOrderTotalAmountLt;
  /**
   * 订单总金额 比较(lte)
   */
  private String processOrderTotalAmountLte;
  /**
   * 订单总金额 比较(contains)
   */
  private String processOrderTotalAmountContains;
  /**
   * 订单总金额 比较(notcontains)
   */
  private String processOrderTotalAmountNotcontains;
  /**
   * 订单总金额 比较(startswith)
   */
  private String processOrderTotalAmountStartswith;
  /**
   * 订单总金额 比较(endswith)
   */
  private String processOrderTotalAmountEndswith;
  /**
   * 订单总金额 比较(isnull)
   */
  private Boolean processOrderTotalAmountIsnull;
  /**
   * 订单总金额 比较(isnotnull)
   */
  private Boolean processOrderTotalAmountIsnotnull;

  /**
   * 订单总金额(精确搜索)
   */
  private List<String> processOrderTotalAmountInList;

  /**
   * 产品状态
   */
  private String processOrderStatus;

  /**
   * 产品状态 比较(eq)
   */
  private String processOrderStatusEq;
  /**
   * 产品状态 比较(neq)
   */
  private String processOrderStatusNeq;
  /**
   * 产品状态 比较(gt)
   */
  private String processOrderStatusGt;
  /**
   * 产品状态 比较(gte)
   */
  private String processOrderStatusGte;
  /**
   * 产品状态 比较(lt)
   */
  private String processOrderStatusLt;
  /**
   * 产品状态 比较(lte)
   */
  private String processOrderStatusLte;
  /**
   * 产品状态 比较(contains)
   */
  private String processOrderStatusContains;
  /**
   * 产品状态 比较(notcontains)
   */
  private String processOrderStatusNotcontains;
  /**
   * 产品状态 比较(startswith)
   */
  private String processOrderStatusStartswith;
  /**
   * 产品状态 比较(endswith)
   */
  private String processOrderStatusEndswith;
  /**
   * 产品状态 比较(isnull)
   */
  private Boolean processOrderStatusIsnull;
  /**
   * 产品状态 比较(isnotnull)
   */
  private Boolean processOrderStatusIsnotnull;

  /**
   * 产品状态(精确搜索)
   */
  private List<String> processOrderStatusInList;

  /**
   * 客选物流
   */
  private Long processOrderLogistics;

  /**
   * 客选物流 比较(eq)
   */
  private Long processOrderLogisticsEq;
  /**
   * 客选物流 比较(neq)
   */
  private Long processOrderLogisticsNeq;
  /**
   * 客选物流 比较(gt)
   */
  private Long processOrderLogisticsGt;
  /**
   * 客选物流 比较(gte)
   */
  private Long processOrderLogisticsGte;
  /**
   * 客选物流 比较(lt)
   */
  private Long processOrderLogisticsLt;
  /**
   * 客选物流 比较(lte)
   */
  private Long processOrderLogisticsLte;
  /**
   * 客选物流 比较(contains)
   */
  private Long processOrderLogisticsContains;
  /**
   * 客选物流 比较(notcontains)
   */
  private Long processOrderLogisticsNotcontains;
  /**
   * 客选物流 比较(startswith)
   */
  private Long processOrderLogisticsStartswith;
  /**
   * 客选物流 比较(endswith)
   */
  private Long processOrderLogisticsEndswith;
  /**
   * 客选物流 比较(isnull)
   */
  private Boolean processOrderLogisticsIsnull;
  /**
   * 客选物流 比较(isnotnull)
   */
  private Boolean processOrderLogisticsIsnotnull;
  /**
   * 客选物流的名称 比较(eq)
   */
  private String processOrderLogisticsLabelEq;
  /**
   * 客选物流的名称 比较(neq)
   */
  private String processOrderLogisticsLabelNeq;
  /**
   * 客选物流的名称 比较(gt)
   */
  private String processOrderLogisticsLabelGt;
  /**
   * 客选物流的名称 比较(gte)
   */
  private String processOrderLogisticsLabelGte;
  /**
   * 客选物流的名称 比较(lt)
   */
  private String processOrderLogisticsLabelLt;
  /**
   * 客选物流的名称 比较(lte)
   */
  private String processOrderLogisticsLabelLte;
  /**
   * 客选物流的名称 比较(contains)
   */
  private String processOrderLogisticsLabelContains;
  /**
   * 客选物流的名称 比较(notcontains)
   */
  private String processOrderLogisticsLabelNotcontains;
  /**
   * 客选物流的名称 比较(startswith)
   */
  private String processOrderLogisticsLabelStartswith;
  /**
   * 客选物流的名称 比较(endswith)
   */
  private String processOrderLogisticsLabelEndswith;
  /**
   * 客选物流的名称 比较(isnull)
   */
  private Boolean processOrderLogisticsLabelIsnull;
  /**
   * 客选物流的名称 比较(isnotnull)
   */
  private Boolean processOrderLogisticsLabelIsnotnull;

  /**
   * 发货截止时间(模糊搜索)
   */
  private String processOrderEndTime;

  /**
   * 发货截止时间 比较(eq)
   */
  private String processOrderEndTimeEq;
  /**
   * 发货截止时间 比较(neq)
   */
  private String processOrderEndTimeNeq;
  /**
   * 发货截止时间 比较(gt)
   */
  private String processOrderEndTimeGt;
  /**
   * 发货截止时间 比较(gte)
   */
  private String processOrderEndTimeGte;
  /**
   * 发货截止时间 比较(lt)
   */
  private String processOrderEndTimeLt;
  /**
   * 发货截止时间 比较(lte)
   */
  private String processOrderEndTimeLte;
  /**
   * 发货截止时间 比较(contains)
   */
  private String processOrderEndTimeContains;
  /**
   * 发货截止时间 比较(notcontains)
   */
  private String processOrderEndTimeNotcontains;
  /**
   * 发货截止时间 比较(startswith)
   */
  private String processOrderEndTimeStartswith;
  /**
   * 发货截止时间 比较(endswith)
   */
  private String processOrderEndTimeEndswith;
  /**
   * 发货截止时间 比较(isnull)
   */
  private Boolean processOrderEndTimeIsnull;
  /**
   * 发货截止时间 比较(isnotnull)
   */
  private Boolean processOrderEndTimeIsnotnull;

  /**
   * 发货截止时间(精确搜索)
   */
  private List<String> processOrderEndTimeInList;

  /**
   * 特殊属性
   */
  private String processOrderSpecial;

  /**
   * 特殊属性 比较(eq)
   */
  private String processOrderSpecialEq;
  /**
   * 特殊属性 比较(neq)
   */
  private String processOrderSpecialNeq;
  /**
   * 特殊属性 比较(gt)
   */
  private String processOrderSpecialGt;
  /**
   * 特殊属性 比较(gte)
   */
  private String processOrderSpecialGte;
  /**
   * 特殊属性 比较(lt)
   */
  private String processOrderSpecialLt;
  /**
   * 特殊属性 比较(lte)
   */
  private String processOrderSpecialLte;
  /**
   * 特殊属性 比较(contains)
   */
  private String processOrderSpecialContains;
  /**
   * 特殊属性 比较(notcontains)
   */
  private String processOrderSpecialNotcontains;
  /**
   * 特殊属性 比较(startswith)
   */
  private String processOrderSpecialStartswith;
  /**
   * 特殊属性 比较(endswith)
   */
  private String processOrderSpecialEndswith;
  /**
   * 特殊属性 比较(isnull)
   */
  private Boolean processOrderSpecialIsnull;
  /**
   * 特殊属性 比较(isnotnull)
   */
  private Boolean processOrderSpecialIsnotnull;

  /**
   * 特殊属性(精确搜索)
   */
  private List<String> processOrderSpecialInList;

  /**
   * 毛利润率(模糊搜索)
   */
  private String processOrderGrossMargin;

  /**
   * 毛利润率 比较(eq)
   */
  private String processOrderGrossMarginEq;
  /**
   * 毛利润率 比较(neq)
   */
  private String processOrderGrossMarginNeq;
  /**
   * 毛利润率 比较(gt)
   */
  private String processOrderGrossMarginGt;
  /**
   * 毛利润率 比较(gte)
   */
  private String processOrderGrossMarginGte;
  /**
   * 毛利润率 比较(lt)
   */
  private String processOrderGrossMarginLt;
  /**
   * 毛利润率 比较(lte)
   */
  private String processOrderGrossMarginLte;
  /**
   * 毛利润率 比较(contains)
   */
  private String processOrderGrossMarginContains;
  /**
   * 毛利润率 比较(notcontains)
   */
  private String processOrderGrossMarginNotcontains;
  /**
   * 毛利润率 比较(startswith)
   */
  private String processOrderGrossMarginStartswith;
  /**
   * 毛利润率 比较(endswith)
   */
  private String processOrderGrossMarginEndswith;
  /**
   * 毛利润率 比较(isnull)
   */
  private Boolean processOrderGrossMarginIsnull;
  /**
   * 毛利润率 比较(isnotnull)
   */
  private Boolean processOrderGrossMarginIsnotnull;

  /**
   * 毛利润率(精确搜索)
   */
  private List<String> processOrderGrossMarginInList;

  /**
   * 执行动作
   */
  private String processAct;

  /**
   * 执行动作 比较(eq)
   */
  private String processActEq;
  /**
   * 执行动作 比较(neq)
   */
  private String processActNeq;
  /**
   * 执行动作 比较(gt)
   */
  private String processActGt;
  /**
   * 执行动作 比较(gte)
   */
  private String processActGte;
  /**
   * 执行动作 比较(lt)
   */
  private String processActLt;
  /**
   * 执行动作 比较(lte)
   */
  private String processActLte;
  /**
   * 执行动作 比较(contains)
   */
  private String processActContains;
  /**
   * 执行动作 比较(notcontains)
   */
  private String processActNotcontains;
  /**
   * 执行动作 比较(startswith)
   */
  private String processActStartswith;
  /**
   * 执行动作 比较(endswith)
   */
  private String processActEndswith;
  /**
   * 执行动作 比较(isnull)
   */
  private Boolean processActIsnull;
  /**
   * 执行动作 比较(isnotnull)
   */
  private Boolean processActIsnotnull;

  /**
   * 执行动作(精确搜索)
   */
  private List<String> processActInList;

  /**
   * 订单平台
   */
  private String issuBaseOrderPlatform;

  /**
   * 订单平台 比较(eq)
   */
  private String issuBaseOrderPlatformEq;
  /**
   * 订单平台 比较(neq)
   */
  private String issuBaseOrderPlatformNeq;
  /**
   * 订单平台 比较(gt)
   */
  private String issuBaseOrderPlatformGt;
  /**
   * 订单平台 比较(gte)
   */
  private String issuBaseOrderPlatformGte;
  /**
   * 订单平台 比较(lt)
   */
  private String issuBaseOrderPlatformLt;
  /**
   * 订单平台 比较(lte)
   */
  private String issuBaseOrderPlatformLte;
  /**
   * 订单平台 比较(contains)
   */
  private String issuBaseOrderPlatformContains;
  /**
   * 订单平台 比较(notcontains)
   */
  private String issuBaseOrderPlatformNotcontains;
  /**
   * 订单平台 比较(startswith)
   */
  private String issuBaseOrderPlatformStartswith;
  /**
   * 订单平台 比较(endswith)
   */
  private String issuBaseOrderPlatformEndswith;
  /**
   * 订单平台 比较(isnull)
   */
  private Boolean issuBaseOrderPlatformIsnull;
  /**
   * 订单平台 比较(isnotnull)
   */
  private Boolean issuBaseOrderPlatformIsnotnull;

  /**
   * 订单平台(精确搜索)
   */
  private List<String> issuBaseOrderPlatformInList;

  /**
   * 订单站点
   */
  private Long issuBaseOrderSite;

  /**
   * 订单站点 比较(eq)
   */
  private Long issuBaseOrderSiteEq;
  /**
   * 订单站点 比较(neq)
   */
  private Long issuBaseOrderSiteNeq;
  /**
   * 订单站点 比较(gt)
   */
  private Long issuBaseOrderSiteGt;
  /**
   * 订单站点 比较(gte)
   */
  private Long issuBaseOrderSiteGte;
  /**
   * 订单站点 比较(lt)
   */
  private Long issuBaseOrderSiteLt;
  /**
   * 订单站点 比较(lte)
   */
  private Long issuBaseOrderSiteLte;
  /**
   * 订单站点 比较(contains)
   */
  private Long issuBaseOrderSiteContains;
  /**
   * 订单站点 比较(notcontains)
   */
  private Long issuBaseOrderSiteNotcontains;
  /**
   * 订单站点 比较(startswith)
   */
  private Long issuBaseOrderSiteStartswith;
  /**
   * 订单站点 比较(endswith)
   */
  private Long issuBaseOrderSiteEndswith;
  /**
   * 订单站点 比较(isnull)
   */
  private Boolean issuBaseOrderSiteIsnull;
  /**
   * 订单站点 比较(isnotnull)
   */
  private Boolean issuBaseOrderSiteIsnotnull;
  /**
   * 订单站点的名称 比较(eq)
   */
  private String issuBaseOrderSiteNameEq;
  /**
   * 订单站点的名称 比较(neq)
   */
  private String issuBaseOrderSiteNameNeq;
  /**
   * 订单站点的名称 比较(gt)
   */
  private String issuBaseOrderSiteNameGt;
  /**
   * 订单站点的名称 比较(gte)
   */
  private String issuBaseOrderSiteNameGte;
  /**
   * 订单站点的名称 比较(lt)
   */
  private String issuBaseOrderSiteNameLt;
  /**
   * 订单站点的名称 比较(lte)
   */
  private String issuBaseOrderSiteNameLte;
  /**
   * 订单站点的名称 比较(contains)
   */
  private String issuBaseOrderSiteNameContains;
  /**
   * 订单站点的名称 比较(notcontains)
   */
  private String issuBaseOrderSiteNameNotcontains;
  /**
   * 订单站点的名称 比较(startswith)
   */
  private String issuBaseOrderSiteNameStartswith;
  /**
   * 订单站点的名称 比较(endswith)
   */
  private String issuBaseOrderSiteNameEndswith;
  /**
   * 订单站点的名称 比较(isnull)
   */
  private Boolean issuBaseOrderSiteNameIsnull;
  /**
   * 订单站点的名称 比较(isnotnull)
   */
  private Boolean issuBaseOrderSiteNameIsnotnull;

  /**
   * 订单店铺
   */
  private Long issuBaseOrderShopInfo;

  /**
   * 订单店铺 比较(eq)
   */
  private Long issuBaseOrderShopInfoEq;
  /**
   * 订单店铺 比较(neq)
   */
  private Long issuBaseOrderShopInfoNeq;
  /**
   * 订单店铺 比较(gt)
   */
  private Long issuBaseOrderShopInfoGt;
  /**
   * 订单店铺 比较(gte)
   */
  private Long issuBaseOrderShopInfoGte;
  /**
   * 订单店铺 比较(lt)
   */
  private Long issuBaseOrderShopInfoLt;
  /**
   * 订单店铺 比较(lte)
   */
  private Long issuBaseOrderShopInfoLte;
  /**
   * 订单店铺 比较(contains)
   */
  private Long issuBaseOrderShopInfoContains;
  /**
   * 订单店铺 比较(notcontains)
   */
  private Long issuBaseOrderShopInfoNotcontains;
  /**
   * 订单店铺 比较(startswith)
   */
  private Long issuBaseOrderShopInfoStartswith;
  /**
   * 订单店铺 比较(endswith)
   */
  private Long issuBaseOrderShopInfoEndswith;
  /**
   * 订单店铺 比较(isnull)
   */
  private Boolean issuBaseOrderShopInfoIsnull;
  /**
   * 订单店铺 比较(isnotnull)
   */
  private Boolean issuBaseOrderShopInfoIsnotnull;
  /**
   * 订单店铺的名称 比较(eq)
   */
  private String issuBaseOrderShopInfoShopNameEq;
  /**
   * 订单店铺的名称 比较(neq)
   */
  private String issuBaseOrderShopInfoShopNameNeq;
  /**
   * 订单店铺的名称 比较(gt)
   */
  private String issuBaseOrderShopInfoShopNameGt;
  /**
   * 订单店铺的名称 比较(gte)
   */
  private String issuBaseOrderShopInfoShopNameGte;
  /**
   * 订单店铺的名称 比较(lt)
   */
  private String issuBaseOrderShopInfoShopNameLt;
  /**
   * 订单店铺的名称 比较(lte)
   */
  private String issuBaseOrderShopInfoShopNameLte;
  /**
   * 订单店铺的名称 比较(contains)
   */
  private String issuBaseOrderShopInfoShopNameContains;
  /**
   * 订单店铺的名称 比较(notcontains)
   */
  private String issuBaseOrderShopInfoShopNameNotcontains;
  /**
   * 订单店铺的名称 比较(startswith)
   */
  private String issuBaseOrderShopInfoShopNameStartswith;
  /**
   * 订单店铺的名称 比较(endswith)
   */
  private String issuBaseOrderShopInfoShopNameEndswith;
  /**
   * 订单店铺的名称 比较(isnull)
   */
  private Boolean issuBaseOrderShopInfoShopNameIsnull;
  /**
   * 订单店铺的名称 比较(isnotnull)
   */
  private Boolean issuBaseOrderShopInfoShopNameIsnotnull;

  /**
   * 发货仓库
   */
  private Long issuWarehouseLogisticsDeliveryWarehouse;

  /**
   * 发货仓库 比较(eq)
   */
  private Long issuWarehouseLogisticsDeliveryWarehouseEq;
  /**
   * 发货仓库 比较(neq)
   */
  private Long issuWarehouseLogisticsDeliveryWarehouseNeq;
  /**
   * 发货仓库 比较(gt)
   */
  private Long issuWarehouseLogisticsDeliveryWarehouseGt;
  /**
   * 发货仓库 比较(gte)
   */
  private Long issuWarehouseLogisticsDeliveryWarehouseGte;
  /**
   * 发货仓库 比较(lt)
   */
  private Long issuWarehouseLogisticsDeliveryWarehouseLt;
  /**
   * 发货仓库 比较(lte)
   */
  private Long issuWarehouseLogisticsDeliveryWarehouseLte;
  /**
   * 发货仓库 比较(contains)
   */
  private Long issuWarehouseLogisticsDeliveryWarehouseContains;
  /**
   * 发货仓库 比较(notcontains)
   */
  private Long issuWarehouseLogisticsDeliveryWarehouseNotcontains;
  /**
   * 发货仓库 比较(startswith)
   */
  private Long issuWarehouseLogisticsDeliveryWarehouseStartswith;
  /**
   * 发货仓库 比较(endswith)
   */
  private Long issuWarehouseLogisticsDeliveryWarehouseEndswith;
  /**
   * 发货仓库 比较(isnull)
   */
  private Boolean issuWarehouseLogisticsDeliveryWarehouseIsnull;
  /**
   * 发货仓库 比较(isnotnull)
   */
  private Boolean issuWarehouseLogisticsDeliveryWarehouseIsnotnull;
  /**
   * 发货仓库的仓库名称 比较(eq)
   */
  private String issuWarehouseLogisticsDeliveryWarehouseNameEq;
  /**
   * 发货仓库的仓库名称 比较(neq)
   */
  private String issuWarehouseLogisticsDeliveryWarehouseNameNeq;
  /**
   * 发货仓库的仓库名称 比较(gt)
   */
  private String issuWarehouseLogisticsDeliveryWarehouseNameGt;
  /**
   * 发货仓库的仓库名称 比较(gte)
   */
  private String issuWarehouseLogisticsDeliveryWarehouseNameGte;
  /**
   * 发货仓库的仓库名称 比较(lt)
   */
  private String issuWarehouseLogisticsDeliveryWarehouseNameLt;
  /**
   * 发货仓库的仓库名称 比较(lte)
   */
  private String issuWarehouseLogisticsDeliveryWarehouseNameLte;
  /**
   * 发货仓库的仓库名称 比较(contains)
   */
  private String issuWarehouseLogisticsDeliveryWarehouseNameContains;
  /**
   * 发货仓库的仓库名称 比较(notcontains)
   */
  private String issuWarehouseLogisticsDeliveryWarehouseNameNotcontains;
  /**
   * 发货仓库的仓库名称 比较(startswith)
   */
  private String issuWarehouseLogisticsDeliveryWarehouseNameStartswith;
  /**
   * 发货仓库的仓库名称 比较(endswith)
   */
  private String issuWarehouseLogisticsDeliveryWarehouseNameEndswith;
  /**
   * 发货仓库的仓库名称 比较(isnull)
   */
  private Boolean issuWarehouseLogisticsDeliveryWarehouseNameIsnull;
  /**
   * 发货仓库的仓库名称 比较(isnotnull)
   */
  private Boolean issuWarehouseLogisticsDeliveryWarehouseNameIsnotnull;

  /**
   * 物流商
   */
  private Long issuWarehouseLogisticsProvider;

  /**
   * 物流商 比较(eq)
   */
  private Long issuWarehouseLogisticsProviderEq;
  /**
   * 物流商 比较(neq)
   */
  private Long issuWarehouseLogisticsProviderNeq;
  /**
   * 物流商 比较(gt)
   */
  private Long issuWarehouseLogisticsProviderGt;
  /**
   * 物流商 比较(gte)
   */
  private Long issuWarehouseLogisticsProviderGte;
  /**
   * 物流商 比较(lt)
   */
  private Long issuWarehouseLogisticsProviderLt;
  /**
   * 物流商 比较(lte)
   */
  private Long issuWarehouseLogisticsProviderLte;
  /**
   * 物流商 比较(contains)
   */
  private Long issuWarehouseLogisticsProviderContains;
  /**
   * 物流商 比较(notcontains)
   */
  private Long issuWarehouseLogisticsProviderNotcontains;
  /**
   * 物流商 比较(startswith)
   */
  private Long issuWarehouseLogisticsProviderStartswith;
  /**
   * 物流商 比较(endswith)
   */
  private Long issuWarehouseLogisticsProviderEndswith;
  /**
   * 物流商 比较(isnull)
   */
  private Boolean issuWarehouseLogisticsProviderIsnull;
  /**
   * 物流商 比较(isnotnull)
   */
  private Boolean issuWarehouseLogisticsProviderIsnotnull;
  /**
   * 物流商的名称 比较(eq)
   */
  private String issuWarehouseLogisticsProviderLabelEq;
  /**
   * 物流商的名称 比较(neq)
   */
  private String issuWarehouseLogisticsProviderLabelNeq;
  /**
   * 物流商的名称 比较(gt)
   */
  private String issuWarehouseLogisticsProviderLabelGt;
  /**
   * 物流商的名称 比较(gte)
   */
  private String issuWarehouseLogisticsProviderLabelGte;
  /**
   * 物流商的名称 比较(lt)
   */
  private String issuWarehouseLogisticsProviderLabelLt;
  /**
   * 物流商的名称 比较(lte)
   */
  private String issuWarehouseLogisticsProviderLabelLte;
  /**
   * 物流商的名称 比较(contains)
   */
  private String issuWarehouseLogisticsProviderLabelContains;
  /**
   * 物流商的名称 比较(notcontains)
   */
  private String issuWarehouseLogisticsProviderLabelNotcontains;
  /**
   * 物流商的名称 比较(startswith)
   */
  private String issuWarehouseLogisticsProviderLabelStartswith;
  /**
   * 物流商的名称 比较(endswith)
   */
  private String issuWarehouseLogisticsProviderLabelEndswith;
  /**
   * 物流商的名称 比较(isnull)
   */
  private Boolean issuWarehouseLogisticsProviderLabelIsnull;
  /**
   * 物流商的名称 比较(isnotnull)
   */
  private Boolean issuWarehouseLogisticsProviderLabelIsnotnull;

  /**
   * 物流方式
   */
  private Long issuWarehouseLogisticsChannel;

  /**
   * 物流方式 比较(eq)
   */
  private Long issuWarehouseLogisticsChannelEq;
  /**
   * 物流方式 比较(neq)
   */
  private Long issuWarehouseLogisticsChannelNeq;
  /**
   * 物流方式 比较(gt)
   */
  private Long issuWarehouseLogisticsChannelGt;
  /**
   * 物流方式 比较(gte)
   */
  private Long issuWarehouseLogisticsChannelGte;
  /**
   * 物流方式 比较(lt)
   */
  private Long issuWarehouseLogisticsChannelLt;
  /**
   * 物流方式 比较(lte)
   */
  private Long issuWarehouseLogisticsChannelLte;
  /**
   * 物流方式 比较(contains)
   */
  private Long issuWarehouseLogisticsChannelContains;
  /**
   * 物流方式 比较(notcontains)
   */
  private Long issuWarehouseLogisticsChannelNotcontains;
  /**
   * 物流方式 比较(startswith)
   */
  private Long issuWarehouseLogisticsChannelStartswith;
  /**
   * 物流方式 比较(endswith)
   */
  private Long issuWarehouseLogisticsChannelEndswith;
  /**
   * 物流方式 比较(isnull)
   */
  private Boolean issuWarehouseLogisticsChannelIsnull;
  /**
   * 物流方式 比较(isnotnull)
   */
  private Boolean issuWarehouseLogisticsChannelIsnotnull;
  /**
   * 物流方式的名称 比较(eq)
   */
  private String issuWarehouseLogisticsChannelLabelEq;
  /**
   * 物流方式的名称 比较(neq)
   */
  private String issuWarehouseLogisticsChannelLabelNeq;
  /**
   * 物流方式的名称 比较(gt)
   */
  private String issuWarehouseLogisticsChannelLabelGt;
  /**
   * 物流方式的名称 比较(gte)
   */
  private String issuWarehouseLogisticsChannelLabelGte;
  /**
   * 物流方式的名称 比较(lt)
   */
  private String issuWarehouseLogisticsChannelLabelLt;
  /**
   * 物流方式的名称 比较(lte)
   */
  private String issuWarehouseLogisticsChannelLabelLte;
  /**
   * 物流方式的名称 比较(contains)
   */
  private String issuWarehouseLogisticsChannelLabelContains;
  /**
   * 物流方式的名称 比较(notcontains)
   */
  private String issuWarehouseLogisticsChannelLabelNotcontains;
  /**
   * 物流方式的名称 比较(startswith)
   */
  private String issuWarehouseLogisticsChannelLabelStartswith;
  /**
   * 物流方式的名称 比较(endswith)
   */
  private String issuWarehouseLogisticsChannelLabelEndswith;
  /**
   * 物流方式的名称 比较(isnull)
   */
  private Boolean issuWarehouseLogisticsChannelLabelIsnull;
  /**
   * 物流方式的名称 比较(isnotnull)
   */
  private Boolean issuWarehouseLogisticsChannelLabelIsnotnull;

  /**
   * 客选物流
   */
  private Long issuOrderLogistics;

  /**
   * 客选物流 比较(eq)
   */
  private Long issuOrderLogisticsEq;
  /**
   * 客选物流 比较(neq)
   */
  private Long issuOrderLogisticsNeq;
  /**
   * 客选物流 比较(gt)
   */
  private Long issuOrderLogisticsGt;
  /**
   * 客选物流 比较(gte)
   */
  private Long issuOrderLogisticsGte;
  /**
   * 客选物流 比较(lt)
   */
  private Long issuOrderLogisticsLt;
  /**
   * 客选物流 比较(lte)
   */
  private Long issuOrderLogisticsLte;
  /**
   * 客选物流 比较(contains)
   */
  private Long issuOrderLogisticsContains;
  /**
   * 客选物流 比较(notcontains)
   */
  private Long issuOrderLogisticsNotcontains;
  /**
   * 客选物流 比较(startswith)
   */
  private Long issuOrderLogisticsStartswith;
  /**
   * 客选物流 比较(endswith)
   */
  private Long issuOrderLogisticsEndswith;
  /**
   * 客选物流 比较(isnull)
   */
  private Boolean issuOrderLogisticsIsnull;
  /**
   * 客选物流 比较(isnotnull)
   */
  private Boolean issuOrderLogisticsIsnotnull;
  /**
   * 客选物流的名称 比较(eq)
   */
  private String issuOrderLogisticsLabelEq;
  /**
   * 客选物流的名称 比较(neq)
   */
  private String issuOrderLogisticsLabelNeq;
  /**
   * 客选物流的名称 比较(gt)
   */
  private String issuOrderLogisticsLabelGt;
  /**
   * 客选物流的名称 比较(gte)
   */
  private String issuOrderLogisticsLabelGte;
  /**
   * 客选物流的名称 比较(lt)
   */
  private String issuOrderLogisticsLabelLt;
  /**
   * 客选物流的名称 比较(lte)
   */
  private String issuOrderLogisticsLabelLte;
  /**
   * 客选物流的名称 比较(contains)
   */
  private String issuOrderLogisticsLabelContains;
  /**
   * 客选物流的名称 比较(notcontains)
   */
  private String issuOrderLogisticsLabelNotcontains;
  /**
   * 客选物流的名称 比较(startswith)
   */
  private String issuOrderLogisticsLabelStartswith;
  /**
   * 客选物流的名称 比较(endswith)
   */
  private String issuOrderLogisticsLabelEndswith;
  /**
   * 客选物流的名称 比较(isnull)
   */
  private Boolean issuOrderLogisticsLabelIsnull;
  /**
   * 客选物流的名称 比较(isnotnull)
   */
  private Boolean issuOrderLogisticsLabelIsnotnull;

  /**
   * 毛利润率(模糊搜索)
   */
  private String issuOrderGrossMargin;

  /**
   * 毛利润率 比较(eq)
   */
  private String issuOrderGrossMarginEq;
  /**
   * 毛利润率 比较(neq)
   */
  private String issuOrderGrossMarginNeq;
  /**
   * 毛利润率 比较(gt)
   */
  private String issuOrderGrossMarginGt;
  /**
   * 毛利润率 比较(gte)
   */
  private String issuOrderGrossMarginGte;
  /**
   * 毛利润率 比较(lt)
   */
  private String issuOrderGrossMarginLt;
  /**
   * 毛利润率 比较(lte)
   */
  private String issuOrderGrossMarginLte;
  /**
   * 毛利润率 比较(contains)
   */
  private String issuOrderGrossMarginContains;
  /**
   * 毛利润率 比较(notcontains)
   */
  private String issuOrderGrossMarginNotcontains;
  /**
   * 毛利润率 比较(startswith)
   */
  private String issuOrderGrossMarginStartswith;
  /**
   * 毛利润率 比较(endswith)
   */
  private String issuOrderGrossMarginEndswith;
  /**
   * 毛利润率 比较(isnull)
   */
  private Boolean issuOrderGrossMarginIsnull;
  /**
   * 毛利润率 比较(isnotnull)
   */
  private Boolean issuOrderGrossMarginIsnotnull;

  /**
   * 毛利润率(精确搜索)
   */
  private List<String> issuOrderGrossMarginInList;

  /**
   * 标发规则
   */
  private String issuActRules;

  /**
   * 标发规则 比较(eq)
   */
  private String issuActRulesEq;
  /**
   * 标发规则 比较(neq)
   */
  private String issuActRulesNeq;
  /**
   * 标发规则 比较(gt)
   */
  private String issuActRulesGt;
  /**
   * 标发规则 比较(gte)
   */
  private String issuActRulesGte;
  /**
   * 标发规则 比较(lt)
   */
  private String issuActRulesLt;
  /**
   * 标发规则 比较(lte)
   */
  private String issuActRulesLte;
  /**
   * 标发规则 比较(contains)
   */
  private String issuActRulesContains;
  /**
   * 标发规则 比较(notcontains)
   */
  private String issuActRulesNotcontains;
  /**
   * 标发规则 比较(startswith)
   */
  private String issuActRulesStartswith;
  /**
   * 标发规则 比较(endswith)
   */
  private String issuActRulesEndswith;
  /**
   * 标发规则 比较(isnull)
   */
  private Boolean issuActRulesIsnull;
  /**
   * 标发规则 比较(isnotnull)
   */
  private Boolean issuActRulesIsnotnull;

  /**
   * 标发规则(精确搜索)
   */
  private List<String> issuActRulesInList;

  /**
   * 创建人
   */
  private Long createUser;

  /**
   * 最小创建人
   */
  private Long createUserMin;

  /**
   * 最大创建人
   */
  private Long createUserMax;

  /**
   * 创建人 比较(eq)
   */
  private Long createUserEq;
  /**
   * 创建人 比较(neq)
   */
  private Long createUserNeq;
  /**
   * 创建人 比较(gt)
   */
  private Long createUserGt;
  /**
   * 创建人 比较(gte)
   */
  private Long createUserGte;
  /**
   * 创建人 比较(lt)
   */
  private Long createUserLt;
  /**
   * 创建人 比较(lte)
   */
  private Long createUserLte;
  /**
   * 创建人 比较(contains)
   */
  private Long createUserContains;
  /**
   * 创建人 比较(notcontains)
   */
  private Long createUserNotcontains;
  /**
   * 创建人 比较(startswith)
   */
  private Long createUserStartswith;
  /**
   * 创建人 比较(endswith)
   */
  private Long createUserEndswith;
  /**
   * 创建人 比较(isnull)
   */
  private Boolean createUserIsnull;
  /**
   * 创建人 比较(isnotnull)
   */
  private Boolean createUserIsnotnull;

  /**
   * 最早创建时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date createTimeStart;

  /**
   * 最晚创建时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date createTimeEnd;

  /**
   * 创建时间 比较(eq)
   */
  private Date createTimeEq;
  /**
   * 创建时间 比较(neq)
   */
  private Date createTimeNeq;
  /**
   * 创建时间 比较(gt)
   */
  private Date createTimeGt;
  /**
   * 创建时间 比较(gte)
   */
  private Date createTimeGte;
  /**
   * 创建时间 比较(lt)
   */
  private Date createTimeLt;
  /**
   * 创建时间 比较(lte)
   */
  private Date createTimeLte;
  /**
   * 创建时间 比较(contains)
   */
  private Date createTimeContains;
  /**
   * 创建时间 比较(notcontains)
   */
  private Date createTimeNotcontains;
  /**
   * 创建时间 比较(startswith)
   */
  private Date createTimeStartswith;
  /**
   * 创建时间 比较(endswith)
   */
  private Date createTimeEndswith;
  /**
   * 创建时间 比较(isnull)
   */
  private Boolean createTimeIsnull;
  /**
   * 创建时间 比较(isnotnull)
   */
  private Boolean createTimeIsnotnull;

  /**
   * 更新人
   */
  private Long lastUpdateUser;

  /**
   * 最小更新人
   */
  private Long lastUpdateUserMin;

  /**
   * 最大更新人
   */
  private Long lastUpdateUserMax;

  /**
   * 更新人 比较(eq)
   */
  private Long lastUpdateUserEq;
  /**
   * 更新人 比较(neq)
   */
  private Long lastUpdateUserNeq;
  /**
   * 更新人 比较(gt)
   */
  private Long lastUpdateUserGt;
  /**
   * 更新人 比较(gte)
   */
  private Long lastUpdateUserGte;
  /**
   * 更新人 比较(lt)
   */
  private Long lastUpdateUserLt;
  /**
   * 更新人 比较(lte)
   */
  private Long lastUpdateUserLte;
  /**
   * 更新人 比较(contains)
   */
  private Long lastUpdateUserContains;
  /**
   * 更新人 比较(notcontains)
   */
  private Long lastUpdateUserNotcontains;
  /**
   * 更新人 比较(startswith)
   */
  private Long lastUpdateUserStartswith;
  /**
   * 更新人 比较(endswith)
   */
  private Long lastUpdateUserEndswith;
  /**
   * 更新人 比较(isnull)
   */
  private Boolean lastUpdateUserIsnull;
  /**
   * 更新人 比较(isnotnull)
   */
  private Boolean lastUpdateUserIsnotnull;

  /**
   * 最早更新时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date lastUpdateTimeStart;

  /**
   * 最晚更新时间
   */
  @DateTimeFormat(pattern = "yyyy-MM-dd")
  private Date lastUpdateTimeEnd;

  /**
   * 更新时间 比较(eq)
   */
  private Date lastUpdateTimeEq;
  /**
   * 更新时间 比较(neq)
   */
  private Date lastUpdateTimeNeq;
  /**
   * 更新时间 比较(gt)
   */
  private Date lastUpdateTimeGt;
  /**
   * 更新时间 比较(gte)
   */
  private Date lastUpdateTimeGte;
  /**
   * 更新时间 比较(lt)
   */
  private Date lastUpdateTimeLt;
  /**
   * 更新时间 比较(lte)
   */
  private Date lastUpdateTimeLte;
  /**
   * 更新时间 比较(contains)
   */
  private Date lastUpdateTimeContains;
  /**
   * 更新时间 比较(notcontains)
   */
  private Date lastUpdateTimeNotcontains;
  /**
   * 更新时间 比较(startswith)
   */
  private Date lastUpdateTimeStartswith;
  /**
   * 更新时间 比较(endswith)
   */
  private Date lastUpdateTimeEndswith;
  /**
   * 更新时间 比较(isnull)
   */
  private Boolean lastUpdateTimeIsnull;
  /**
   * 更新时间 比较(isnotnull)
   */
  private Boolean lastUpdateTimeIsnotnull;

  /**
   * 表单名称
   */
  private String formName;

  /**
   * 工作流状态
   */
  private Integer wfStatus;
}
